ObjFW  Diff

		} else
			cls->info |= OBJC_CLASS_INFO_LOADED;
	}

	process_load_queue();
}

Class __saveds
objc_allocateClassPair(Class superclass OBJC_M68K_REG("a0"),
Class
objc_allocateClassPair(Class superclass, const char *name, size_t extra_bytes)
    const char *name OBJC_M68K_REG("a1"),
    size_t extra_bytes OBJC_M68K_REG("d0"))
{
	struct objc_class *cls, *metaclass;
	Class iter, rootclass = Nil;

	if (extra_bytes > LONG_MAX)
		OBJC_ERROR("extra_bytes out of range!")

	metaclass->info = OBJC_CLASS_INFO_CLASS;
	metaclass->instance_size = (superclass != Nil ?
	    superclass->isa->instance_size : 0) + (long)extra_bytes;

	return cls;
}

void __saveds
objc_registerClassPair(Class cls OBJC_M68K_REG("a0"))
void
objc_registerClassPair(Class cls)
{
	objc_global_mutex_lock();

	register_class((struct objc_abi_class *)cls);

	if (cls->superclass != Nil) {
		add_subclass(cls);

Class
objc_get_class(const char *name)
{
	return objc_getRequiredClass(name);
}

unsigned int __saveds
objc_getClassList(Class *buf OBJC_M68K_REG("a0"),
unsigned int
objc_getClassList(Class *buf, unsigned int count)
    unsigned int count OBJC_M68K_REG("d0"))
{
	unsigned int j;
	objc_global_mutex_lock();

	if (buf == NULL)
		return classes_cnt;

	}

	objc_global_mutex_unlock();

	return j;
}

Class *__saveds
objc_copyClassList(unsigned int *len OBJC_M68K_REG("a0"))
Class *
objc_copyClassList(unsigned int *len)
{
	Class *ret;
	unsigned int count;

	objc_global_mutex_lock();

	if ((ret = malloc((classes_cnt + 1) * sizeof(Class))) == NULL)

		*len = count;

	objc_global_mutex_unlock();

	return ret;
}

bool __saveds
class_isMetaClass(Class cls OBJC_M68K_REG("a0"))
bool
class_isMetaClass(Class cls)
{
	if (cls == Nil)
		return false;

	return (cls->info & OBJC_CLASS_INFO_METACLASS);
}

const char *__saveds
class_getName(Class cls OBJC_M68K_REG("a0"))
const char *
class_getName(Class cls)
{
	if (cls == Nil)
		return "";

	return cls->name;
}

Class __saveds
class_getSuperclass(Class cls OBJC_M68K_REG("a0"))
Class
class_getSuperclass(Class cls)
{
	if (cls == Nil)
		return Nil;

	return cls->superclass;
}

unsigned long __saveds
class_getInstanceSize(Class cls OBJC_M68K_REG("a0"))
unsigned long
class_getInstanceSize(Class cls)
{
	if (cls == Nil)
		return 0;

	return cls->instance_size;
}

IMP __saveds
class_getMethodImplementation(Class cls OBJC_M68K_REG("a0"),
IMP
class_getMethodImplementation(Class cls, SEL sel)
    SEL sel OBJC_M68K_REG("a1"))
{
	/*
	 * We use a dummy object here so that the normal lookup is used, even
	 * though we don't have an object. Doing so is safe, as objc_msg_lookup
	 * does not access the object, but only its class.
	 *
	 * Just looking it up in the dispatch table could result in returning

	if (cls == Nil)
		return NULL;

	dummy.isa = cls;
	return objc_msg_lookup((id)&dummy, sel);
}

IMP __saveds
class_getMethodImplementation_stret(Class cls OBJC_M68K_REG("a0"),
IMP
class_getMethodImplementation_stret(Class cls, SEL sel)
    SEL sel OBJC_M68K_REG("a1"))
{
	/*
	 * Same as above, but use objc_msg_lookup_stret instead, so that the
	 * correct forwarding handler is returned.
	 */
	struct {
		Class isa;

	ml->methods[0].imp = imp;

	cls->methodlist = ml;

	objc_update_dtable(cls);
}

const char *__saveds
class_getMethodTypeEncoding(Class cls OBJC_M68K_REG("a0"),
const char *
class_getMethodTypeEncoding(Class cls, SEL sel)
    SEL sel OBJC_M68K_REG("a1"))
{
	struct objc_method *method;

	if (cls == Nil)
		return NULL;

	objc_global_mutex_lock();

	if (cls->superclass != Nil)
		return class_getMethodTypeEncoding(cls->superclass, sel);

	return NULL;
}

bool __saveds
class_addMethod(Class cls OBJC_M68K_REG("a0"), SEL sel OBJC_M68K_REG("a1"),
bool
class_addMethod(Class cls, SEL sel, IMP imp, const char *types)
    IMP imp OBJC_M68K_REG("a2"), const char *types OBJC_M68K_REG("a3"))
{
	bool ret;

	objc_global_mutex_lock();

	if (get_method(cls, sel) == NULL) {
		add_method(cls, sel, imp, types);
		ret = true;
	} else
		ret = false;

	objc_global_mutex_unlock();

	return ret;
}

IMP __saveds
class_replaceMethod(Class cls OBJC_M68K_REG("a0"), SEL sel OBJC_M68K_REG("a1"),
IMP
class_replaceMethod(Class cls, SEL sel, IMP newimp, const char *types)
    IMP newimp OBJC_M68K_REG("a2"), const char *types OBJC_M68K_REG("a3"))
{
	struct objc_method *method;
	IMP oldimp;

	objc_global_mutex_lock();

	if ((method = get_method(cls, sel)) != NULL) {
		oldimp = method->imp;
		method->imp = newimp;
		objc_update_dtable(cls);
	} else {
		oldimp = NULL;
		add_method(cls, sel, newimp, types);
	}

	objc_global_mutex_unlock();

	return oldimp;
}

Class __saveds
object_getClass(id obj_ OBJC_M68K_REG("a0"))
Class
object_getClass(id obj_)
{
	struct objc_object *obj;

	if (obj_ == nil)
		return Nil;

	obj = (struct objc_object *)obj_;

	return obj->isa;
}

Class __saveds
object_setClass(id obj_ OBJC_M68K_REG("a0"), Class cls OBJC_M68K_REG("a1"))
Class
object_setClass(id obj_, Class cls)
{
	struct objc_object *obj;
	Class old;

	if (obj_ == nil)
		return Nil;

	obj = (struct objc_object *)obj_;

	old = obj->isa;
	obj->isa = cls;

	return old;
}

const char *__saveds
object_getClassName(id obj OBJC_M68K_REG("a0"))
const char *
object_getClassName(id obj)
{
	return class_getName(object_getClass(obj));
}

static void
unregister_class(Class rcls)
{