/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC * type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new type object instance. */
UninstantiableInstance *obj = mem_allocate_zeroed_typed(UninstantiableInstance);
/* Build an STable. */
PMC *st_pmc = create_stable(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Create type object and point it back at the STable. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
return st->WHAT;
}
/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC * type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new object instance. */
HashAttrStoreInstance *obj = mem_allocate_zeroed_typed(HashAttrStoreInstance);
/* Build an STable. */
PMC *st_pmc = create_stable(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Create type object and point it back at the STable. We leave the
* hash store pointer null to flag it's the type object. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
return st->WHAT;
}
/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC * type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new object instance. */
P6bigintInstance *obj = mem_allocate_zeroed_typed(P6bigintInstance);
/* Build an STable. */
PMC *st_pmc = create_stable_func(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Create type object and point it back at the STable. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object_func(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
/* Flag it as a type object. */
MARK_AS_TYPE_OBJECT(st->WHAT);
return st->WHAT;
}
/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC * type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new object instance. */
P6opaqueInstance *obj = mem_allocate_zeroed_typed(P6opaqueInstance);
/* Build an STable. */
PMC *st_pmc = create_stable(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Create REPR data structure and hand it off the STable. */
st->REPR_data = mem_allocate_zeroed_typed(P6opaqueREPRData);
/* Create type object and point it back at the STable. Note that we
* do *not* populate the spill pointer at all, we leave it null. A
* non-null value (even PMCNULL) is what indicates we have a defined
* object. Yes, I know, it's sick. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
return st->WHAT;
}
/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC *type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new object instance. */
CStrInstance *obj = mem_allocate_zeroed_typed(CStrInstance);
/* Build an STable. */
PMC *st_pmc = create_stable_func(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Create REPR data structure and hang it off the STable. */
/* Don't need any REPR data yet. */
/*st->REPR_data = mem_allocate_zeroed_typed(CStrREPRData);*/
/* Create type object and point it back at the STable. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object_func(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
/* Flag it as a type object. */
MARK_AS_TYPE_OBJECT(st->WHAT);
return st->WHAT;
}
/* Creates a new type object of this representation, and associates it with
* the given HOW. */
static PMC * type_object_for(PARROT_INTERP, PMC *HOW) {
/* Create new object instance. */
P6numInstance *obj = mem_allocate_zeroed_typed(P6numInstance);
P6numREPRData *repr_data = mem_allocate_zeroed_typed(P6numREPRData);
/* Build an STable. */
PMC *st_pmc = create_stable(interp, this_repr, HOW);
STable *st = STABLE_STRUCT(st_pmc);
/* Set default bit width value in the REPR data and attach it to the
* STable. */
repr_data->bits = sizeof(FLOATVAL)*8;
st->REPR_data = repr_data;
/* Create type object and point it back at the STable. */
obj->common.stable = st_pmc;
st->WHAT = wrap_object(interp, obj);
PARROT_GC_WRITE_BARRIER(interp, st_pmc);
/* Flag it as a type object. */
MARK_AS_TYPE_OBJECT(st->WHAT);
return st->WHAT;
}
/* Bootstraps the KnowHOW. This is were things "bottom out" in the meta-model
* so it's a tad loopy. Basically, we create a KnowHOW type object. We then
* create an instance from that and add a bunch of methods to it. Returns the
* bootstrapped object. */
PMC * SixModelObject_bootstrap_knowhow(PARROT_INTERP, PMC *sc) {
/* Create our KnowHOW type object. Note we don't have a HOW just yet, so
* pass in null. */
REPROps *REPR = REPR_get_by_name(interp, Parrot_str_new_constant(interp, "KnowHOWREPR"));
PMC *knowhow_pmc = REPR->type_object_for(interp, PMCNULL);
/* We create a KnowHOW instance that can describe itself. This means
* .HOW.HOW.HOW.HOW etc will always return that, which closes the model
* up. Also pull out its underlying struct. */
PMC *knowhow_how_pmc = REPR->allocate(interp, NULL);
KnowHOWREPRInstance *knowhow_how = (KnowHOWREPRInstance *)PMC_data(knowhow_how_pmc);
/* Need to give the knowhow_how a twiddled STable with a different
* dispatcher, so things bottom out. */
PMC *st_copy = create_stable(interp, REPR, knowhow_how_pmc);
STABLE_STRUCT(st_copy)->WHAT = knowhow_pmc;
STABLE_STRUCT(st_copy)->find_method = bottom_find_method;
knowhow_how->common.stable = st_copy;
/* Add various methods to the KnowHOW's HOW. */
knowhow_how->body.methods = Parrot_pmc_new(interp, enum_class_Hash);
knowhow_how->body.attributes = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "new_type"),
wrap_c(interp, F2DPTR(new_type)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "find_method"),
wrap_c(interp, F2DPTR(find_method)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "add_method"),
wrap_c(interp, F2DPTR(add_method)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "add_attribute"),
wrap_c(interp, F2DPTR(add_attribute)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "compose"),
wrap_c(interp, F2DPTR(compose)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "parents"),
wrap_c(interp, F2DPTR(parents)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "attributes"),
wrap_c(interp, F2DPTR(attributes)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "methods"),
wrap_c(interp, F2DPTR(methods)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "mro"),
wrap_c(interp, F2DPTR(mro)));
VTABLE_set_pmc_keyed_str(interp, knowhow_how->body.methods,
Parrot_str_new_constant(interp, "name"),
wrap_c(interp, F2DPTR(name)));
/* Set name KnowHOW for the KnowHOW's HOW. */
knowhow_how->body.name = Parrot_str_new_constant(interp, "KnowHOW");
/* Set this built up HOW as the KnowHOW's HOW. */
STABLE(knowhow_pmc)->HOW = knowhow_how_pmc;
/* Give it an authoritative method cache. */
STABLE(knowhow_pmc)->method_cache = knowhow_how->body.methods;
STABLE(knowhow_pmc)->mode_flags = METHOD_CACHE_AUTHORITATIVE;
/* Set up some string constants that the methods here use. */
repr_str = Parrot_str_new_constant(interp, "repr");
name_str = Parrot_str_new_constant(interp, "name");
empty_str = Parrot_str_new_constant(interp, "");
p6opaque_str = Parrot_str_new_constant(interp, "P6opaque");
/* Associate the created objects with the intial core serialization
* context. */
VTABLE_set_pmc_keyed_int(interp, sc, 0, knowhow_pmc);
SC_PMC(knowhow_pmc) = sc;
VTABLE_set_pmc_keyed_int(interp, sc, 1, knowhow_how_pmc);
SC_PMC(knowhow_how_pmc) = sc;
STABLE(knowhow_pmc)->sc = sc;
STABLE(knowhow_how_pmc)->sc = sc;
return knowhow_pmc;
}