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() : ""; }