void objc_register_all_classes(struct objc_abi_symtab* symtab) {
uint_fast32_t i;
for (i = 0; i < symtab->cls_def_cnt; i++) {
struct objc_abi_class* cls = (struct objc_abi_class*)symtab->defs[i];
register_class(cls);
register_selectors(cls);
register_selectors((struct objc_abi_class*)object_getClass((id)cls));
}
for (i = 0; i < symtab->cls_def_cnt; i++) {
Class cls = (Class)symtab->defs[i];
if (has_load(cls)) {
setup_class(cls);
if (cls->info & OBJC_CLASS_INFO_SETUP)
call_load(cls);
else {
if (load_queue == NULL)
load_queue = malloc(sizeof(Class));
else
load_queue = realloc(load_queue, sizeof(Class) * (load_queue_cnt + 1));
if (load_queue == NULL)
OBJC_ERROR(
"Not enough memory for load "
"queue!");
load_queue[load_queue_cnt++] = cls;
}
} else
cls->info |= OBJC_CLASS_INFO_LOADED;
}
/* Process load queue */
for (i = 0; i < load_queue_cnt; i++) {
setup_class(load_queue[i]);
if (load_queue[i]->info & OBJC_CLASS_INFO_SETUP) {
call_load(load_queue[i]);
load_queue_cnt--;
if (load_queue_cnt == 0) {
free(load_queue);
load_queue = NULL;
continue;
}
load_queue[i] = load_queue[load_queue_cnt];
load_queue = realloc(load_queue, sizeof(Class) * load_queue_cnt);
if (load_queue == NULL)
OBJC_ERROR("Not enough memory for load queue!");
}
}
}
extern "C" CLASS *init(CALLBACKS *fntable, MODULE *module, int argc, char *argv[])
{
callback=fntable;
myclass=(CLASS*)((*(callback->class_getname))("test"));
if (!myclass) return NULL;
if (!setup_class(myclass)) return NULL;
return myclass;}
void objc_initialize_class(Class cls) {
if (cls->info & OBJC_CLASS_INFO_INITIALIZED)
return;
objc_global_mutex_lock();
/*
* It's possible that two threads try to initialize a class at the same
* time. Make sure that the thread which held the lock did not already
* initialize it.
*/
if (cls->info & OBJC_CLASS_INFO_INITIALIZED) {
objc_global_mutex_unlock();
return;
}
setup_class(cls);
if (!(cls->info & OBJC_CLASS_INFO_SETUP)) {
objc_global_mutex_unlock();
return;
}
initialize_class(cls);
objc_global_mutex_unlock();
}
struct RClass*
mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
{
struct RClass *c = 0;
if (mrb_const_defined(mrb, outer, id)) {
mrb_value v = mrb_const_get(mrb, outer, id);
c = mrb_class_ptr(v);
if (!mrb_nil_p(super) && (c->tt != MRB_TT_CLASS || c->super != mrb_class_ptr(super))) {
c = 0;
}
}
if (!c) {
struct RClass *s = 0;
if (!mrb_nil_p(super)) {
mrb_check_type(mrb, super, MRB_TT_CLASS);
s = mrb_class_ptr(super);
}
if (!s) {
s = mrb->object_class;
}
c = mrb_class_new(mrb, s);
setup_class(mrb, outer, c, id);
mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c));
}
return c;
}
/*!
* Defines a class under the namespace of \a outer.
* \param outer a class which contains the new class.
* \param id name of the new class
* \param super a class from which the new class will derive.
* NULL means \c Object class.
* \return the created class
* \throw TypeError if the constant name \a name is already taken but
* the constant is not a \c Class.
* \throw NameError if the class is already defined but the class can not
* be reopened because its superclass is not \a super.
* \post top-level constant named \a name refers the returned class.
*
* \note if a class named \a name is already defined and its superclass is
* \a super, the function just returns the defined class.
*/
struct RClass *
mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
{
struct RClass * c;
mrb_sym id = mrb_intern(mrb, name);
if (mrb_const_defined_at(mrb, outer, id)) {
c = mrb_class_from_sym(mrb, outer, id);
if (c->tt != MRB_TT_CLASS) {
mrb_raise(mrb, E_TYPE_ERROR, "%s is not a class", mrb_sym2name(mrb, id));
}
if (mrb_class_real(c->super) != super) {
mrb_name_error(mrb, id, "%s is already defined", mrb_sym2name(mrb, id));
}
return c;
}
if (!super) {
mrb_warn("no super class for `%s::%s', Object assumed",
mrb_obj_classname(mrb, mrb_obj_value(outer)), mrb_sym2name(mrb, id));
}
c = mrb_class_new(mrb, super);
setup_class(mrb, mrb_obj_value(outer), c, id);
mrb_const_set(mrb, mrb_obj_value(outer), id, mrb_obj_value(c));
return c;
}
struct RClass*
mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
{
struct RClass *c = 0;
if (mrb_const_defined(mrb, outer, id)) {
mrb_value v = mrb_const_get(mrb, outer, id);
c = mrb_class_ptr(v);
if (!mrb_nil_p(super) && (c->tt != MRB_TT_CLASS || c->super != mrb_class_ptr(super))) {
c = 0;
}
}
if (!c) {
struct RClass *s = 0;
if (!mrb_nil_p(super)) {
mrb_check_type(mrb, super, MRB_TT_CLASS);
s = mrb_class_ptr(super);
}
c = mrb_class_new(mrb, s);
setup_class(mrb, outer, c, id);
}
return c;
}
OBJCRT_EXPORT void objc_registerClassPair(Class cls) {
objc_global_mutex_lock();
// metaclass super is set up by setup_class.
setup_class(cls);
objc_hashtable_set(classes, cls->name, cls);
initialize_class(cls);
objc_global_mutex_unlock();
}
struct RClass *
mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
{
struct RClass * c;
mrb_sym id = mrb_intern(mrb, name);
if (mrb_const_defined_at(mrb, outer, id)) {
c = class_from_sym(mrb, outer, id);
return c;
}
c = mrb_module_new(mrb);
setup_class(mrb, mrb_obj_value(outer), c, id);
return c;
}
struct RClass*
mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
{
struct RClass *c;
mrb_value v;
if (mrb_const_defined(mrb, outer, id)) {
v = mrb_const_get(mrb, outer, id);
c = mrb_class_ptr(v);
}
else {
c = mrb_module_new(mrb);
setup_class(mrb, outer, c, id);
}
return c;
}
struct RClass *
mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
{
struct RClass * c;
mrb_sym id = mrb_intern(mrb, name);
if (mrb_const_defined_at(mrb, outer, id)) {
c = mrb_class_from_sym(mrb, outer, id);
if (c->tt != MRB_TT_MODULE) {
mrb_raise(mrb, E_TYPE_ERROR, "%s is not a module", mrb_sym2name(mrb, id));
}
return c;
}
c = mrb_module_new(mrb);
setup_class(mrb, mrb_obj_value(outer), c, id);
mrb_const_set(mrb, mrb_obj_value(outer), id, mrb_obj_value(c));
return c;
}
Class objc_lookup_class(const char* name) {
Class cls = objc_classname_to_class(name);
if (cls == NULL)
return Nil;
if (cls->info & OBJC_CLASS_INFO_SETUP)
return cls;
objc_global_mutex_lock();
setup_class(cls);
objc_global_mutex_unlock();
if (!(cls->info & OBJC_CLASS_INFO_SETUP))
return Nil;
return cls;
}
/*!
* Defines a class under the namespace of \a outer.
* \param outer a class which contains the new class.
* \param id name of the new class
* \param super a class from which the new class will derive.
* NULL means \c Object class.
* \return the created class
* \throw TypeError if the constant name \a name is already taken but
* the constant is not a \c Class.
* \throw NameError if the class is already defined but the class can not
* be reopened because its superclass is not \a super.
* \post top-level constant named \a name refers the returned class.
*
* \note if a class named \a name is already defined and its superclass is
* \a super, the function just returns the defined class.
*/
struct RClass *
mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
{
struct RClass * c;
mrb_sym id = mrb_intern(mrb, name);
if (mrb_const_defined_at(mrb, outer, id)) {
c = class_from_sym(mrb, outer, id);
if (mrb_class_real(c->super) != super) {
mrb_name_error(mrb, id, "%S is already defined", name);
}
return c;
}
if (!super) {
mrb_warn(mrb, "no super class for `%S::%S', Object assumed", outer, name);
}
c = mrb_class_new(mrb, super);
setup_class(mrb, mrb_obj_value(outer), c, id);
return c;
}
struct RClass*
mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
{
struct RClass *c, *s;
if (mrb_const_defined(mrb, outer, id)) {
mrb_value v = mrb_const_get(mrb, outer, id);
mrb_check_type(mrb, v, MRB_TT_CLASS);
c = mrb_class_ptr(v);
if (!mrb_nil_p(super)) {
if (mrb_type(super) != MRB_TT_CLASS) {
mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
}
if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) {
mrb_raise(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id));
}
}
return c;
}
if (!mrb_nil_p(super)) {
if (mrb_type(super) != MRB_TT_CLASS) {
mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super));
}
s = mrb_class_ptr(super);
}
else {
s = mrb->object_class;
}
c = mrb_class_new(mrb, s);
setup_class(mrb, outer, c, id);
mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c));
return c;
}
PUBLIC void init_plugin_evtsettings(void) {
setup_class();
}
PUBLIC void init_plugin_midievt_cc(void) {
setup_class();
}
PUBLIC void init_plugin_midievt_noteoff(void) {
setup_class();
}
PUBLIC void init_plugin_random(void) {
setup_class();
}
static void setup_class(Class cls) {
const char* superclass;
Class metaclass = object_getClass((id)cls);
if (cls->info & OBJC_CLASS_INFO_SETUP)
return;
if ((superclass = ((struct objc_abi_class*)cls)->superclass) != NULL) {
Class super = Nil;
// Classes loaded from the image contain a superclass name instead of a superclass. Resolve it.
if ((cls->info & OBJC_CLASS_INFO_CREATED_RUNTIME) == 0) {
super = objc_classname_to_class(superclass);
} else {
super = (Class)superclass;
}
if (super == (Class)nil)
return;
setup_class(super);
if (!(super->info & OBJC_CLASS_INFO_SETUP))
return;
cls->superclass = super;
metaclass->superclass = object_getClass((id)super);
add_subclass(cls);
add_subclass(metaclass);
} else
metaclass->superclass = cls;
// Calculate size based on ivars
int slide = 0;
cls->instance_size = -(int)cls->instance_size;
if (cls->superclass) {
slide = cls->superclass->instance_size;
}
if (slide) {
struct objc_ivar_list* list = (struct objc_ivar_list*)cls->ivars;
if (list) {
// If first ivar has a negative offset (???) .. increase slide by that amount
if (list->count > 0) {
if ((int)list->ivars[0].offset < 0) {
printf("Warning: Class %s has first ivar %s with a negative offset of %d!\n",
cls->name,
list->ivars[0].name,
list->ivars[0].offset);
slide += -(int)list->ivars[0].offset;
}
}
for (unsigned i = 0; i < list->count; i++) {
struct objc_ivar* curIvar = &list->ivars[i];
curIvar->offset += slide;
*((int**)cls->ivar_offsets)[i] += slide;
assert(*((int**)cls->ivar_offsets)[i] == curIvar->offset);
}
}
}
cls->instance_size += slide;
cls->info |= OBJC_CLASS_INFO_SETUP;
metaclass->info |= OBJC_CLASS_INFO_SETUP;
metaclass->instance_size = sizeof(struct objc_class);
}
PUBLIC void init_plugin_lowpass(void) {
setup_class();
}
PUBLIC void init_plugin_seqnote(void) {
setup_class();
}
PUBLIC void init_plugin_filerequester(void) {
setup_class();
}
PUBLIC void init_plugin_integrate(void) {
setup_class();
}
PUBLIC void init_plugin_pcm_out(void) {
setup_class();
}
PUBLIC void init_plugin_sndfile_in(void) {
setup_class();
}
PUBLIC void init_plugin_evtinteger(void) {
setup_class();
}
PUBLIC void init_plugin_dcbias(void) {
setup_class();
}
PUBLIC void init_plugin_glscale(void) {
setup_class();
}
PUBLIC void init_plugin_esd_output(void) {
setup_class();
}
PUBLIC void init_plugin_ctrl(void) {
setup_class();
}
PUBLIC void init_plugin_reverse(void) {
setup_class();
}
