void test_metaclass_is_completely_setup() {
Class *cls;
MetaClass *meta;
cls = (Class*)G(klass);
meta = (MetaClass*)cls->klass();
TS_ASSERT(kind_of<MetaClass>(G(object)->klass()));
TS_ASSERT(kind_of<LookupTable>(meta->method_table()));
TS_ASSERT(kind_of<LookupTable>(meta->constants()));
}
// ### currently hardcoded, should change
int Sn::ConvX::getConcreteType(const char* buffer)
{
MetaClass* mc = getMetaClass("PxBase", META_DATA_SRC);
assert(mc);
PxMetaDataEntry entry;
if(mc->getFieldByType("PxType", entry))
{
// PT: safe to cast to int here since we're reading our own PxType
return (int)peek(entry.mSize, buffer + entry.mOffset);
}
assert(0);
return 0xffffffff;
}
Walker::ApplyStatus PointerMetaClass::walk(const Address address,Walker &w) const {
MetaClass *link = get_base_type();
Address ** ptr = (Address **)address;
if (!ptr)
return Walker::Continue;
if (!(*ptr))
return Walker::Continue;
if (w.is_changed(*ptr))
return Walker::Continue;
if (w.is_walkable(*ptr,_pointer_owns_object,link))
return link->walk(*ptr,w);
return Walker::Continue;
}
void MetaClass::Info::show(STATE, Object* self, int level) {
MetaClass* cls = as<MetaClass>(self);
Module* mod = try_as<Module>(cls->attached_instance());
const char* name;
if(mod) {
name = mod->name()->nil_p() ? "<anonymous>" : mod->name()->c_str(state);
} else {
name = "<some object>";
}
std::cout << "#<MetaClass:" << self->class_object(state)->name()->c_str(state) <<
" " << name << ":" << (void*)self << ">" << std::endl;
}
bool MetaClass::operator == (const MetaClass &other) const {
if ( this == &other ) return true;
if ( 0 == strcmp(this->GetClassName(), other.GetClassName()))
return true;
else
return false;
}
MetaClass* MetaClass::attach(STATE, Object* obj, Object* sup) {
MetaClass *meta;
meta = (MetaClass*)state->new_object(G(metaclass));
if(!sup) { sup = obj->klass(); }
meta->IsMeta = TRUE;
meta->attached_instance(state, obj);
meta->setup(state);
meta->superclass(state, (Module*)sup);
obj->klass(state, meta);
meta->name(state, state->symbol("<metaclass>"));
/** @todo These fields from Class are not set. Need to? --rue
Fixnum* instance_fields_; // slot
Fixnum* instance_type_; // slot
*/
return meta;
}
MetaClass* MetaClass::attach(STATE, Object* obj, Object* sup) {
MetaClass *meta;
meta = state->om->new_object_enduring<MetaClass>(G(metaclass));
meta->set_class_id(state->shared.inc_class_count());
if(!sup) { sup = obj->klass(); }
meta->attached_instance(state, obj);
meta->setup(state);
meta->superclass(state, (Module*)sup);
meta->set_type_info(obj->klass()->type_info());
obj->klass(state, meta);
meta->name(state, state->symbol("<metaclass>"));
/** @todo These fields from Class are not set. Need to? --rue
Fixnum* instance_type_; // slot
*/
return meta;
}
MetaClass* MetaClass::attach(STATE, Object* obj, Class* sup) {
MetaClass *meta;
meta = state->om->new_object_enduring<MetaClass>(G(klass));
meta->set_class_id(state->shared.inc_class_count());
meta->attached_instance(state, obj);
meta->setup(state);
meta->set_type_info(obj->klass()->type_info());
meta->set_packed_size(obj->klass()->packed_size());
meta->packed_ivar_info(state, obj->klass()->packed_ivar_info());
/* The superclass hierarchy for metaclasses lives in parallel to that of classes.
* This code ensures that the superclasses of metaclasses are also metaclasses.
*/
if(MetaClass* already_meta = try_as<MetaClass>(obj)) {
/* If we are attaching a metaclass to something that is already a MetaClass,
* make the metaclass's superclass be the attachee's superclass.
* klass and superclass are both metaclasses in this case.
*/
meta->klass(state, meta);
meta->superclass(state, already_meta->true_superclass(state)->metaclass(state));
} else {
/* If we are attaching to anything but a MetaClass, the new
* metaclass's class is the same as its superclass.
* This is where the superclass chains for meta/non-meta classes diverge.
* If no superclass argument was provided, we use the klass we are replacing.
*/
if(!sup) { sup = obj->klass(); }
/* Tell the new MetaClass about the attachee's existing hierarchy */
Class* meta_klass = Class::real_class(state, sup)->klass();
meta->klass(state, meta_klass);
meta->superclass(state, sup);
}
meta->name(state, state->symbol("<metaclass>"));
/* Finally, attach the new MetaClass */
obj->klass(state, meta);
return meta;
}
bool isInstanceOfClass(const MetaClass& theClass) const
{
return metaClass != NULL ? metaClass->isInstanceOfClass(theClass) : false;
}
const char * getClassName() const
{
return metaClass != nullptr ? metaClass->getClassName() : "";
}
