MVMObject * MVM_proc_getenvhash(MVMThreadContext *tc) {
MVMInstance * const instance = tc->instance;
MVMObject * env_hash;
#ifdef _WIN32
const MVMuint16 acp = GetACP(); /* We should get ACP at runtime. */
#endif
MVMuint32 pos = 0;
MVMString *needle = MVM_string_ascii_decode(tc, instance->VMString, STR_WITH_LEN("="));
char *env;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&needle);
env_hash = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_hash_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&env_hash);
while ((env = environ[pos++]) != NULL) {
#ifndef _WIN32
MVMString *str = MVM_string_utf8_c8_decode(tc, instance->VMString, env, strlen(env));
#else
char * const _env = ANSIToUTF8(acp, env);
MVMString *str = MVM_string_utf8_c8_decode(tc, instance->VMString, _env, strlen(_env));
#endif
MVMuint32 index = MVM_string_index(tc, str, needle, 0);
MVMString *key, *val;
MVMObject *box;
#ifdef _WIN32
MVM_free(_env);
#endif
MVM_gc_root_temp_push(tc, (MVMCollectable **)&str);
key = MVM_string_substring(tc, str, 0, index);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&key);
val = MVM_string_substring(tc, str, index + 1, -1);
box = MVM_repr_box_str(tc, MVM_hll_current(tc)->str_box_type, val);
MVM_repr_bind_key_o(tc, env_hash, key, box);
MVM_gc_root_temp_pop_n(tc, 2);
}
MVM_gc_root_temp_pop_n(tc, 2);
return env_hash;
}
MVMObject * MVM_proc_getenvhash(MVMThreadContext *tc) {
static MVMObject *env_hash;
if (!env_hash) {
#ifdef _WIN32
MVMuint16 acp = GetACP(); /* We should get ACP at runtime. */
#endif
MVMuint32 pos = 0;
MVMString *needle = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, "=", 1, MVM_encoding_type_ascii);
char *env;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&needle);
env_hash = MVM_repr_alloc_init(tc, tc->instance->boot_types->BOOTHash);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&env_hash);
while ((env = environ[pos++]) != NULL) {
#ifndef _WIN32
MVMString *str = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, env, strlen(env), MVM_encoding_type_utf8);
#else
char * const _env = ANSIToUTF8(acp, env);
MVMString *str = MVM_decode_C_buffer_to_string(tc, tc->instance->VMString, _env, strlen(_env), MVM_encoding_type_utf8);
#endif
MVMuint32 index = MVM_string_index(tc, str, needle, 0);
MVMString *key, *val;
#ifdef _WIN32
free(_env);
#endif
MVM_gc_root_temp_push(tc, (MVMCollectable **)&str);
key = MVM_string_substring(tc, str, 0, index);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&key);
val = MVM_string_substring(tc, str, index + 1, -1);
MVM_repr_bind_key_boxed(tc, env_hash, key, (MVMObject *)val);
MVM_gc_root_temp_pop_n(tc, 2);
}
MVM_gc_root_temp_pop_n(tc, 2);
}
return env_hash;
}
static void Str_say(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
MVMObject* self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
MVM_args_proc_cleanup(tc, &arg_ctx);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&self);
MVMString * self_s = REPR(self)->box_funcs->get_str(tc, STABLE(self), self, OBJECT_BODY(self));
MVM_string_say(tc, self_s);
MVM_gc_root_temp_pop_n(tc, 1);
}
/* KnowHOW.new_type method. Creates a new type with this HOW as its meta-object. */
static void new_type(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMObject *self, *HOW, *type_object, *BOOTHash, *stash;
MVMArgInfo repr_arg, name_arg;
MVMString *repr_name, *name;
const MVMREPROps *repr_to_use;
MVMInstance *instance = tc->instance;
/* Get arguments. */
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
MVM_args_checkarity(tc, &arg_ctx, 1, 1);
self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
repr_arg = MVM_args_get_named_str(tc, &arg_ctx, instance->str_consts.repr, MVM_ARG_OPTIONAL);
name_arg = MVM_args_get_named_str(tc, &arg_ctx, instance->str_consts.name, MVM_ARG_OPTIONAL);
MVM_args_proc_cleanup(tc, &arg_ctx);
if (REPR(self)->ID != MVM_REPR_ID_KnowHOWREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW methods must be called on object with REPR KnowHOWREPR");
/* See if we have a representation name; if not default to P6opaque. */
repr_name = repr_arg.exists ? repr_arg.arg.s : instance->str_consts.P6opaque;
repr_to_use = MVM_repr_get_by_name(tc, repr_name);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&name_arg);
/* We first create a new HOW instance. */
HOW = REPR(self)->allocate(tc, STABLE(self));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&HOW);
/* Create a new type object of the desired REPR. (Note that we can't
* default to KnowHOWREPR here, since it doesn't know how to actually
* store attributes, it's just for bootstrapping knowhow's. */
type_object = repr_to_use->type_object_for(tc, HOW);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&type_object);
/* This may move name_arg.arg.s so do it first: */
REPR(HOW)->initialize(tc, STABLE(HOW), HOW, OBJECT_BODY(HOW));
/* See if we were given a name; put it into the meta-object if so. */
name = name_arg.exists ? name_arg.arg.s : instance->str_consts.anon;
MVM_ASSIGN_REF(tc, &(HOW->header), ((MVMKnowHOWREPR *)HOW)->body.name, name);
/* Set .WHO to an empty hash. */
BOOTHash = tc->instance->boot_types.BOOTHash;
stash = REPR(BOOTHash)->allocate(tc, STABLE(BOOTHash));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&stash);
MVM_ASSIGN_REF(tc, &(STABLE(type_object)->header), STABLE(type_object)->WHO, stash);
/* Return the type object. */
MVM_args_set_result_obj(tc, type_object, MVM_RETURN_CURRENT_FRAME);
MVM_gc_root_temp_pop_n(tc, 4);
}
static void File_eof(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
MVMObject* self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
MVM_args_proc_cleanup(tc, &arg_ctx);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&self);
MVMint64 result = MVM_file_eof(tc, self);
MVM_args_set_result_int(tc, result, MVM_RETURN_CURRENT_FRAME);
MVM_gc_root_temp_pop_n(tc, 1);
}
static void Str_length(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
MVMObject* self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
MVM_args_proc_cleanup(tc, &arg_ctx);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&self);
MVMString * self_s = REPR(self)->box_funcs->get_str(tc, STABLE(self), self, OBJECT_BODY(self));
MVMint64 length = NUM_GRAPHS((MVMString*)self_s);
MVM_args_set_result_int(tc, length, MVM_RETURN_CURRENT_FRAME);
MVM_gc_root_temp_pop_n(tc, 1);
}
/* Locates all of the attributes. Puts them onto a flattened, ordered
* list of attributes (populating the passed flat_list). Also builds
* the index mapping for doing named lookups. Note index is not related
* to the storage position. */
static MVMObject * index_mapping_and_flat_list(MVMThreadContext *tc, MVMObject *mro, MVMCPPStructREPRData *repr_data) {
MVMInstance *instance = tc->instance;
MVMObject *flat_list, *class_list, *attr_map_list;
MVMint32 num_classes, i, current_slot = 0;
MVMCPPStructNameMap *result;
MVMint32 mro_idx = MVM_repr_elems(tc, mro);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&mro);
flat_list = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_array_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&flat_list);
class_list = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_array_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&class_list);
attr_map_list = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_array_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_map_list);
/* Walk through the parents list. */
while (mro_idx)
{
/* Get current class in MRO. */
MVMObject *type_info = MVM_repr_at_pos_o(tc, mro, --mro_idx);
MVMObject *current_class = MVM_repr_at_pos_o(tc, type_info, 0);
/* Get its local parents; make sure we're not doing MI. */
MVMObject *parents = MVM_repr_at_pos_o(tc, type_info, 2);
MVMint32 num_parents = MVM_repr_elems(tc, parents);
if (num_parents <= 1) {
/* Get attributes and iterate over them. */
MVMObject *attributes = MVM_repr_at_pos_o(tc, type_info, 1);
MVMIter * const attr_iter = (MVMIter *)MVM_iter(tc, attributes);
MVMObject *attr_map = NULL;
if (MVM_iter_istrue(tc, attr_iter)) {
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_iter);
attr_map = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_hash_type);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_map);
}
while (MVM_iter_istrue(tc, attr_iter)) {
MVMObject *current_slot_obj = MVM_repr_box_int(tc, MVM_hll_current(tc)->int_box_type, current_slot);
MVMObject *attr, *name_obj;
MVMString *name;
MVM_repr_shift_o(tc, (MVMObject *)attr_iter);
/* Get attribute. */
attr = MVM_iterval(tc, attr_iter);
/* Get its name. */
name_obj = MVM_repr_at_key_o(tc, attr, instance->str_consts.name);
name = MVM_repr_get_str(tc, name_obj);
MVM_repr_bind_key_o(tc, attr_map, name, current_slot_obj);
current_slot++;
/* Push attr onto the flat list. */
MVM_repr_push_o(tc, flat_list, attr);
}
if (attr_map) {
MVM_gc_root_temp_pop_n(tc, 2);
}
/* Add to class list and map list. */
MVM_repr_push_o(tc, class_list, current_class);
MVM_repr_push_o(tc, attr_map_list, attr_map);
}
else {
MVM_exception_throw_adhoc(tc,
"CPPStruct representation does not support multiple inheritance");
}
}
MVM_gc_root_temp_pop_n(tc, 4);
/* We can now form the name map. */
num_classes = MVM_repr_elems(tc, class_list);
result = (MVMCPPStructNameMap *) MVM_malloc(sizeof(MVMCPPStructNameMap) * (1 + num_classes));
for (i = 0; i < num_classes; i++) {
result[i].class_key = MVM_repr_at_pos_o(tc, class_list, i);
result[i].name_map = MVM_repr_at_pos_o(tc, attr_map_list, i);
}
/* set the end to be NULL, it's useful for iteration. */
result[i].class_key = NULL;
repr_data->name_to_index_mapping = result;
return flat_list;
}
static char callback_handler(DCCallback *cb, DCArgs *cb_args, DCValue *cb_result, MVMNativeCallback *data) {
CallbackInvokeData cid;
MVMint32 num_roots, i;
MVMRegister res;
/* Build a callsite and arguments buffer. */
MVMThreadContext *tc = data->tc;
MVMRegister *args = MVM_malloc(data->num_types * sizeof(MVMRegister));
num_roots = 0;
for (i = 1; i < data->num_types; i++) {
MVMObject *type = data->types[i];
MVMint16 typeinfo = data->typeinfos[i];
switch (typeinfo & MVM_NATIVECALL_ARG_TYPE_MASK) {
case MVM_NATIVECALL_ARG_CHAR:
args[i - 1].i64 = dcbArgChar(cb_args);
break;
case MVM_NATIVECALL_ARG_SHORT:
args[i - 1].i64 = dcbArgShort(cb_args);
break;
case MVM_NATIVECALL_ARG_INT:
args[i - 1].i64 = dcbArgInt(cb_args);
break;
case MVM_NATIVECALL_ARG_LONG:
args[i - 1].i64 = dcbArgLong(cb_args);
break;
case MVM_NATIVECALL_ARG_LONGLONG:
args[i - 1].i64 = dcbArgLongLong(cb_args);
break;
case MVM_NATIVECALL_ARG_FLOAT:
args[i - 1].n64 = dcbArgFloat(cb_args);
break;
case MVM_NATIVECALL_ARG_DOUBLE:
args[i - 1].n64 = dcbArgDouble(cb_args);
break;
case MVM_NATIVECALL_ARG_ASCIISTR:
case MVM_NATIVECALL_ARG_UTF8STR:
case MVM_NATIVECALL_ARG_UTF16STR:
args[i - 1].o = MVM_nativecall_make_str(tc, type, typeinfo,
(char *)dcbArgPointer(cb_args));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CSTRUCT:
args[i - 1].o = MVM_nativecall_make_cstruct(tc, type,
dcbArgPointer(cb_args));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CPOINTER:
args[i - 1].o = MVM_nativecall_make_cpointer(tc, type,
dcbArgPointer(cb_args));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CARRAY:
args[i - 1].o = MVM_nativecall_make_carray(tc, type,
dcbArgPointer(cb_args));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CUNION:
args[i - 1].o = MVM_nativecall_make_cunion(tc, type,
dcbArgPointer(cb_args));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CALLBACK:
/* TODO: A callback -return- value means that we have a C method
* that needs to be wrapped similarly to a is native(...) Perl 6
* sub. */
dcbArgPointer(cb_args);
args[i - 1].o = type;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
case MVM_NATIVECALL_ARG_UCHAR:
args[i - 1].i64 = dcbArgUChar(cb_args);
break;
case MVM_NATIVECALL_ARG_USHORT:
args[i - 1].i64 = dcbArgUShort(cb_args);
break;
case MVM_NATIVECALL_ARG_UINT:
args[i - 1].i64 = dcbArgUInt(cb_args);
break;
case MVM_NATIVECALL_ARG_ULONG:
args[i - 1].i64 = dcbArgULong(cb_args);
break;
case MVM_NATIVECALL_ARG_ULONGLONG:
args[i - 1].i64 = dcbArgULongLong(cb_args);
break;
default:
MVM_exception_throw_adhoc(tc,
"Internal error: unhandled dyncall callback argument type");
}
}
/* Call into a nested interpreter (since we already are in one). Need to
* save a bunch of state around each side of this. */
cid.invokee = data->target;
cid.args = args;
cid.cs = data->cs;
{
MVMuint8 **backup_interp_cur_op = tc->interp_cur_op;
MVMuint8 **backup_interp_bytecode_start = tc->interp_bytecode_start;
MVMRegister **backup_interp_reg_base = tc->interp_reg_base;
MVMCompUnit **backup_interp_cu = tc->interp_cu;
MVMFrame *backup_cur_frame = tc->cur_frame;
MVMFrame *backup_thread_entry_frame = tc->thread_entry_frame;
MVMuint32 backup_mark = MVM_gc_root_temp_mark(tc);
jmp_buf backup_interp_jump;
memcpy(backup_interp_jump, tc->interp_jump, sizeof(jmp_buf));
tc->cur_frame->return_value = &res;
tc->cur_frame->return_type = MVM_RETURN_OBJ;
MVM_interp_run(tc, &callback_invoke, &cid);
tc->interp_cur_op = backup_interp_cur_op;
tc->interp_bytecode_start = backup_interp_bytecode_start;
tc->interp_reg_base = backup_interp_reg_base;
tc->interp_cu = backup_interp_cu;
tc->cur_frame = backup_cur_frame;
tc->thread_entry_frame = backup_thread_entry_frame;
memcpy(tc->interp_jump, backup_interp_jump, sizeof(jmp_buf));
MVM_gc_root_temp_mark_reset(tc, backup_mark);
}
/* Handle return value. */
if (res.o) {
MVMContainerSpec const *contspec = STABLE(res.o)->container_spec;
if (contspec && contspec->fetch_never_invokes)
contspec->fetch(data->tc, res.o, &res);
}
switch (data->typeinfos[0] & MVM_NATIVECALL_ARG_TYPE_MASK) {
case MVM_NATIVECALL_ARG_VOID:
break;
case MVM_NATIVECALL_ARG_CHAR:
cb_result->c = MVM_nativecall_unmarshal_char(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_SHORT:
cb_result->s = MVM_nativecall_unmarshal_short(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_INT:
cb_result->i = MVM_nativecall_unmarshal_int(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_LONG:
cb_result->j = MVM_nativecall_unmarshal_long(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_LONGLONG:
cb_result->l = MVM_nativecall_unmarshal_longlong(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_FLOAT:
cb_result->f = MVM_nativecall_unmarshal_float(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_DOUBLE:
cb_result->d = MVM_nativecall_unmarshal_double(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_ASCIISTR:
case MVM_NATIVECALL_ARG_UTF8STR:
case MVM_NATIVECALL_ARG_UTF16STR:
cb_result->Z = MVM_nativecall_unmarshal_string(data->tc, res.o, data->typeinfos[0], NULL);
break;
case MVM_NATIVECALL_ARG_CSTRUCT:
cb_result->p = MVM_nativecall_unmarshal_cstruct(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_CPOINTER:
cb_result->p = MVM_nativecall_unmarshal_cpointer(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_CARRAY:
cb_result->p = MVM_nativecall_unmarshal_carray(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_CUNION:
cb_result->p = MVM_nativecall_unmarshal_cunion(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_VMARRAY:
cb_result->p = MVM_nativecall_unmarshal_vmarray(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_CALLBACK:
cb_result->p = unmarshal_callback(data->tc, res.o, data->types[0]);
break;
case MVM_NATIVECALL_ARG_UCHAR:
cb_result->c = MVM_nativecall_unmarshal_uchar(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_USHORT:
cb_result->s = MVM_nativecall_unmarshal_ushort(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_UINT:
cb_result->i = MVM_nativecall_unmarshal_uint(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_ULONG:
cb_result->j = MVM_nativecall_unmarshal_ulong(data->tc, res.o);
break;
case MVM_NATIVECALL_ARG_ULONGLONG:
cb_result->l = MVM_nativecall_unmarshal_ulonglong(data->tc, res.o);
break;
default:
MVM_exception_throw_adhoc(data->tc,
"Internal error: unhandled dyncall callback return type");
}
/* Clean up. */
MVM_gc_root_temp_pop_n(tc, num_roots);
MVM_free(args);
/* Indicate what we're producing as a result. */
return get_signature_char(data->typeinfos[0]);
}
/* Composes the meta-object. */
static void compose(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
MVMObject *self, *type_obj, *method_table, *attributes, *BOOTArray, *BOOTHash,
*repr_info_hash, *repr_info, *type_info, *attr_info_list, *parent_info;
MVMint64 num_attrs, i;
/* Get arguments. */
MVMArgProcContext arg_ctx; arg_ctx.named_used = NULL;
MVM_args_proc_init(tc, &arg_ctx, callsite, args);
self = MVM_args_get_pos_obj(tc, &arg_ctx, 0, MVM_ARG_REQUIRED).arg.o;
type_obj = MVM_args_get_pos_obj(tc, &arg_ctx, 1, MVM_ARG_REQUIRED).arg.o;
MVM_args_proc_cleanup(tc, &arg_ctx);
if (!self || !IS_CONCRETE(self) || REPR(self)->ID != MVM_REPR_ID_KnowHOWREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW methods must be called on object instance with REPR KnowHOWREPR");
/* Fill out STable. */
method_table = ((MVMKnowHOWREPR *)self)->body.methods;
MVM_ASSIGN_REF(tc, STABLE(type_obj), STABLE(type_obj)->method_cache, method_table);
STABLE(type_obj)->mode_flags = MVM_METHOD_CACHE_AUTHORITATIVE;
STABLE(type_obj)->type_check_cache_length = 1;
STABLE(type_obj)->type_check_cache = malloc(sizeof(MVMObject *));
MVM_ASSIGN_REF(tc, STABLE(type_obj), STABLE(type_obj)->type_check_cache[0], type_obj);
/* Next steps will allocate, so make sure we keep hold of the type
* object and ourself. */
MVM_gc_root_temp_push(tc, (MVMCollectable **)&self);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&type_obj);
/* Use any attribute information to produce attribute protocol
* data. The protocol consists of an array... */
BOOTArray = tc->instance->boot_types->BOOTArray;
BOOTHash = tc->instance->boot_types->BOOTHash;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&BOOTArray);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&BOOTHash);
repr_info = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&repr_info);
REPR(repr_info)->initialize(tc, STABLE(repr_info), repr_info, OBJECT_BODY(repr_info));
/* ...which contains an array per MRO entry (just us)... */
type_info = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&type_info);
REPR(type_info)->initialize(tc, STABLE(type_info), type_info, OBJECT_BODY(type_info));
MVM_repr_push_o(tc, repr_info, type_info);
/* ...which in turn contains this type... */
MVM_repr_push_o(tc, type_info, type_obj);
/* ...then an array of hashes per attribute... */
attr_info_list = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_info_list);
REPR(attr_info_list)->initialize(tc, STABLE(attr_info_list), attr_info_list,
OBJECT_BODY(attr_info_list));
MVM_repr_push_o(tc, type_info, attr_info_list);
attributes = ((MVMKnowHOWREPR *)self)->body.attributes;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attributes);
num_attrs = REPR(attributes)->elems(tc, STABLE(attributes),
attributes, OBJECT_BODY(attributes));
for (i = 0; i < num_attrs; i++) {
MVMObject *attr_info = REPR(BOOTHash)->allocate(tc, STABLE(BOOTHash));
MVMKnowHOWAttributeREPR *attribute = (MVMKnowHOWAttributeREPR *)
MVM_repr_at_pos_o(tc, attributes, i);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attr_info);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attribute);
if (REPR((MVMObject *)attribute)->ID != MVM_REPR_ID_KnowHOWAttributeREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW attributes must use KnowHOWAttributeREPR");
REPR(attr_info)->initialize(tc, STABLE(attr_info), attr_info,
OBJECT_BODY(attr_info));
REPR(attr_info)->ass_funcs->bind_key_boxed(tc, STABLE(attr_info),
attr_info, OBJECT_BODY(attr_info), (MVMObject *)str_name, (MVMObject *)attribute->body.name);
REPR(attr_info)->ass_funcs->bind_key_boxed(tc, STABLE(attr_info),
attr_info, OBJECT_BODY(attr_info), (MVMObject *)str_type, attribute->body.type);
if (attribute->body.box_target) {
/* Merely having the key serves as a "yes". */
REPR(attr_info)->ass_funcs->bind_key_boxed(tc, STABLE(attr_info),
attr_info, OBJECT_BODY(attr_info), (MVMObject *)str_box_target, attr_info);
}
MVM_repr_push_o(tc, attr_info_list, attr_info);
MVM_gc_root_temp_pop_n(tc, 2);
}
/* ...followed by a list of parents (none). */
parent_info = REPR(BOOTArray)->allocate(tc, STABLE(BOOTArray));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&parent_info);
REPR(parent_info)->initialize(tc, STABLE(parent_info), parent_info,
OBJECT_BODY(parent_info));
MVM_repr_push_o(tc, type_info, parent_info);
/* Finally, this all goes in a hash under the key 'attribute'. */
repr_info_hash = REPR(BOOTHash)->allocate(tc, STABLE(BOOTHash));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&repr_info_hash);
REPR(repr_info_hash)->initialize(tc, STABLE(repr_info_hash), repr_info_hash, OBJECT_BODY(repr_info_hash));
REPR(repr_info_hash)->ass_funcs->bind_key_boxed(tc, STABLE(repr_info_hash),
repr_info_hash, OBJECT_BODY(repr_info_hash), (MVMObject *)str_attribute, repr_info);
/* Compose the representation using it. */
REPR(type_obj)->compose(tc, STABLE(type_obj), repr_info_hash);
/* Clear temporary roots. */
MVM_gc_root_temp_pop_n(tc, 10);
/* Return type object. */
MVM_args_set_result_obj(tc, type_obj, MVM_RETURN_CURRENT_FRAME);
}
/* Returns a list of hashes containing file, line, sub and annotations. */
MVMObject * MVM_exception_backtrace(MVMThreadContext *tc, MVMObject *ex_obj) {
MVMFrame *cur_frame;
MVMObject *arr = NULL, *annotations = NULL, *row = NULL, *value = NULL;
MVMuint32 count = 0;
MVMString *k_file = NULL, *k_line = NULL, *k_sub = NULL, *k_anno = NULL;
if (IS_CONCRETE(ex_obj) && REPR(ex_obj)->ID == MVM_REPR_ID_MVMException)
cur_frame = ((MVMException *)ex_obj)->body.origin;
else
MVM_exception_throw_adhoc(tc, "Op 'backtrace' needs an exception object");
MVM_gc_root_temp_push(tc, (MVMCollectable **)&arr);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&annotations);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&row);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&value);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&k_file);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&k_line);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&k_sub);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&k_anno);
k_file = MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "file");
k_line = MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "line");
k_sub = MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "sub");
k_anno = MVM_string_ascii_decode_nt(tc, tc->instance->VMString, "annotations");
arr = MVM_repr_alloc_init(tc, tc->instance->boot_types.BOOTArray);
while (cur_frame != NULL) {
MVMuint8 *cur_op = count ? cur_frame->return_address : cur_frame->throw_address;
MVMuint32 offset = cur_op - cur_frame->effective_bytecode;
MVMBytecodeAnnotation *annot = MVM_bytecode_resolve_annotation(tc, &cur_frame->static_info->body,
offset > 0 ? offset - 1 : 0);
MVMint32 fshi = annot ? (MVMint32)annot->filename_string_heap_index : -1;
char *line_number = malloc(16);
snprintf(line_number, 16, "%d", annot ? annot->line_number : 1);
/* annotations hash will contain "file" and "line" */
annotations = MVM_repr_alloc_init(tc, tc->instance->boot_types.BOOTHash);
/* file */
if (fshi >= 0 && fshi < cur_frame->static_info->body.cu->body.num_strings)
value = MVM_repr_box_str(tc, MVM_hll_current(tc)->str_box_type,
cur_frame->static_info->body.cu->body.strings[fshi]);
else
value = MVM_repr_box_str(tc, MVM_hll_current(tc)->str_box_type,
cur_frame->static_info->body.cu->body.filename);
MVM_repr_bind_key_o(tc, annotations, k_file, value);
/* line */
value = (MVMObject *)MVM_string_ascii_decode_nt(tc, tc->instance->VMString, line_number);
value = MVM_repr_box_str(tc, MVM_hll_current(tc)->str_box_type, (MVMString *)value);
MVM_repr_bind_key_o(tc, annotations, k_line, value);
free(line_number);
/* row will contain "sub" and "annotations" */
row = MVM_repr_alloc_init(tc, tc->instance->boot_types.BOOTHash);
MVM_repr_bind_key_o(tc, row, k_sub, cur_frame->code_ref);
MVM_repr_bind_key_o(tc, row, k_anno, annotations);
MVM_repr_push_o(tc, arr, row);
cur_frame = cur_frame->caller;
while (cur_frame && cur_frame->static_info->body.is_thunk)
cur_frame = cur_frame->caller;
count++;
}
MVM_gc_root_temp_pop_n(tc, 8);
return arr;
}
