/* 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);
}
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);
}
/* XXX inline parent's strands if it's a rope too? */
MVMString * MVM_string_concatenate(MVMThreadContext *tc, MVMString *a, MVMString *b) {
MVMString *result;
MVMStrandIndex strand_count = 0;
MVMStrand *strands;
MVMStringIndex index = 0;
MVMStrandIndex max_strand_depth = 0;
MVMStringIndex agraphs = NUM_GRAPHS(a), bgraphs = NUM_GRAPHS(b), rgraphs;
if (!IS_CONCRETE((MVMObject *)a) || !IS_CONCRETE((MVMObject *)b)) {
MVM_exception_throw_adhoc(tc, "Concatenate needs concrete strings");
}
MVM_gc_root_temp_push(tc, (MVMCollectable **)&a);
result = (MVMString *)REPR(a)->allocate(tc, STABLE(a));
MVM_gc_root_temp_pop(tc);
/* there could be unattached combining chars at the beginning of b,
so, XXX TODO handle this */
result->body.flags = MVM_STRING_TYPE_ROPE;
rgraphs = agraphs + bgraphs;
if (agraphs)
strand_count = 1;
if (bgraphs)
++strand_count;
strands = result->body.strands = calloc(sizeof(MVMStrand), strand_count + 1);
strand_count = 0;
if (agraphs) {
strands->string = a;
strands->string_offset = 0;
strands->compare_offset = index;
index = agraphs;
strand_count = 1;
max_strand_depth = STRAND_DEPTH(a);
}
if (bgraphs) {
strands[strand_count].string = b;
strands[strand_count].string_offset = 0;
strands[strand_count].compare_offset = index;
index += bgraphs;
++strand_count;
if (STRAND_DEPTH(b) > max_strand_depth)
max_strand_depth = STRAND_DEPTH(b);
}
strands[strand_count].graphs = index;
result->body.num_strands = strand_count;
result->body.flags = MVM_STRING_TYPE_ROPE;
_STRAND_DEPTH(result) = max_strand_depth + 1;
return result;
}
MVMString * MVM_string_repeat(MVMThreadContext *tc, MVMString *a, MVMint64 count) {
MVMString *result;
MVMint64 bkup_count = count;
MVMStringIndex string_offset = 0, graphs = 0, rgraphs;
if (!IS_CONCRETE((MVMObject *)a)) {
MVM_exception_throw_adhoc(tc, "repeat needs a concrete string");
}
if (count < 0)
MVM_exception_throw_adhoc(tc, "repeat count (%lld) cannot be negative", count);
if (count > (1<<30))
MVM_exception_throw_adhoc(tc, "repeat count > %lld arbitrarily unsupported...", (1<<30));
MVM_gc_root_temp_push(tc, (MVMCollectable **)&a);
result = (MVMString *)REPR(a)->allocate(tc, STABLE(a));
MVM_gc_root_temp_pop(tc);
if (IS_ONE_STRING_ROPE(a)) {
string_offset = a->body.strands->string_offset;
graphs = a->body.strands[1].graphs;
a = a->body.strands->string;
}
else {
graphs = NUM_GRAPHS(a);
}
rgraphs = graphs * count;
/* XXX compute tradeoff here of space usage of the strands table vs real string */
if (rgraphs) {
MVMStrand *strands = result->body.strands = calloc(sizeof(MVMStrand), count + 1);
result->body.flags = MVM_STRING_TYPE_ROPE;
while (count--) {
strands[count].compare_offset = count * graphs;
strands[count].string = a;
strands[count].string_offset = string_offset;
}
strands[bkup_count].graphs = rgraphs;
result->body.num_strands = bkup_count;
_STRAND_DEPTH(result) = STRAND_DEPTH(a) + 1;
}
else {
result->body.flags = MVM_STRING_TYPE_UINT8;
/* leave graphs 0 and storage null */
}
return result;
}
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);
}
/* Returns a substring of the given string */
MVMString * MVM_string_substring(MVMThreadContext *tc, MVMString *a, MVMint64 start, MVMint64 length) {
MVMString *result;
MVMStrand *strands;
MVMStringIndex agraphs = NUM_GRAPHS(a);
if (start < 0) {
start += agraphs;
if (start < 0)
start = 0;
}
if (!IS_CONCRETE((MVMObject *)a)) {
MVM_exception_throw_adhoc(tc, "Substring needs a concrete string");
}
if (start > agraphs)
start = agraphs;
if (length == -1) /* -1 signifies go to the end of the string */
length = agraphs - start;
if (length < 0)
MVM_exception_throw_adhoc(tc, "Substring length (%lld) cannot be negative", length);
if (start + length > agraphs)
length = agraphs - start;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&a);
result = (MVMString *)REPR(a)->allocate(tc, STABLE(a));
MVM_gc_root_temp_pop(tc);
strands = result->body.strands = calloc(sizeof(MVMStrand), 2);
/* if we're substringing a substring, substring the same one */
if (IS_ONE_STRING_ROPE(a)) {
strands->string_offset = (MVMStringIndex)start + a->body.strands->string_offset;
strands->string = a->body.strands->string;
}
else {
strands->string_offset = (MVMStringIndex)start;
strands->string = a;
}
/* result->body.codes = 0; /* Populate this lazily. */
result->body.flags = MVM_STRING_TYPE_ROPE;
result->body.num_strands = 1;
strands[1].graphs = length;
_STRAND_DEPTH(result) = STRAND_DEPTH(strands->string) + 1;
return result;
}
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);
}
void MVM_thread_join(MVMThreadContext *tc, MVMObject *thread_obj) {
if (REPR(thread_obj)->ID == MVM_REPR_ID_MVMThread) {
MVMThread *thread = (MVMThread *)thread_obj;
int status;
MVM_gc_root_temp_push(tc, (MVMCollectable **)&thread);
MVM_gc_mark_thread_blocked(tc);
if (((MVMThread *)thread_obj)->body.stage < MVM_thread_stage_exited) {
status = uv_thread_join(&thread->body.thread);
}
else { /* the target already ended */
/* used to be APR_SUCCESS, but then we ditched APR */
status = 0;
}
MVM_gc_mark_thread_unblocked(tc);
MVM_gc_root_temp_pop(tc);
if (status < 0)
MVM_panic(MVM_exitcode_compunit, "Could not join thread: errorcode %d", status);
}
else {
MVM_exception_throw_adhoc(tc,
"Thread handle passed to join must have representation MVMThread");
}
}
MVMObject * MVM_thread_start(MVMThreadContext *tc, MVMObject *invokee, MVMObject *result_type) {
int status;
ThreadStart *ts;
MVMObject *child_obj;
/* Create a thread object to wrap it up in. */
MVM_gc_root_temp_push(tc, (MVMCollectable **)&invokee);
child_obj = REPR(result_type)->allocate(tc, STABLE(result_type));
MVM_gc_root_temp_pop(tc);
if (REPR(child_obj)->ID == MVM_REPR_ID_MVMThread) {
MVMThread *child = (MVMThread *)child_obj;
MVMThread * volatile *threads;
/* Create a new thread context and set it up. */
MVMThreadContext *child_tc = MVM_tc_create(tc->instance);
child->body.tc = child_tc;
MVM_ASSIGN_REF(tc, child, child->body.invokee, invokee);
child_tc->thread_obj = child;
child_tc->thread_id = MVM_incr(&tc->instance->next_user_thread_id);
/* Create the thread. Note that we take a reference to the current frame,
* since it must survive to be the dynamic scope of where the thread was
* started, and there's no promises that the thread won't start before
* the code creating the thread returns. The count is decremented when
* the thread is done. */
ts = malloc(sizeof(ThreadStart));
ts->tc = child_tc;
ts->caller = MVM_frame_inc_ref(tc, tc->cur_frame);
ts->thread_obj = child_obj;
/* push this to the *child* tc's temp roots. */
MVM_gc_root_temp_push(child_tc, (MVMCollectable **)&ts->thread_obj);
/* Signal to the GC we have a childbirth in progress. The GC
* will null it for us. */
MVM_gc_mark_thread_blocked(child_tc);
MVM_ASSIGN_REF(tc, tc->thread_obj, tc->thread_obj->body.new_child, child);
/* push to starting threads list */
threads = &tc->instance->threads;
do {
MVMThread *curr = *threads;
MVM_ASSIGN_REF(tc, child, child->body.next, curr);
} while (MVM_casptr(threads, child->body.next, child) != child->body.next);
status = uv_thread_create(&child->body.thread, &start_thread, ts);
if (status < 0) {
MVM_panic(MVM_exitcode_compunit, "Could not spawn thread: errorcode %d", status);
}
/* need to run the GC to clear our new_child field in case we try
* try to launch another thread before the GC runs and before the
* thread starts. */
GC_SYNC_POINT(tc);
}
else {
MVM_exception_throw_adhoc(tc,
"Thread result type must have representation MVMThread");
}
return child_obj;
}
/* 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);
}
static void callback_handler(ffi_cif *cif, void *cb_result, void **cb_args, void *cb_data) {
CallbackInvokeData cid;
MVMint32 num_roots, i;
MVMRegister res;
MVMRegister *args;
MVMNativeCallback *data = (MVMNativeCallback *)cb_data;
void **values = MVM_malloc(sizeof(void *) * (data->cs->arg_count ? data->cs->arg_count : 1));
unsigned int interval_id;
/* Locate the MoarVM thread this callback is being run on. */
MVMThreadContext *tc = MVM_nativecall_find_thread_context(data->instance);
/* Unblock GC if needed, so this thread can do work. */
MVMint32 was_blocked = MVM_gc_is_thread_blocked(tc);
if (was_blocked)
MVM_gc_mark_thread_unblocked(tc);
interval_id = MVM_telemetry_interval_start(tc, "nativecall callback handler");
/* Build a callsite and arguments buffer. */
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 = *(signed char *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_SHORT:
args[i - 1].i64 = *(signed short *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_INT:
args[i - 1].i64 = *(signed int *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_LONG:
args[i - 1].i64 = *(signed long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_LONGLONG:
args[i - 1].i64 = *(signed long long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_FLOAT:
args[i - 1].n64 = *(float *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_DOUBLE:
args[i - 1].n64 = *(double *)cb_args[i - 1];
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 **)cb_args[i - 1]);
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, *(void **)cb_args[i - 1]);
MVM_gc_root_temp_push(tc, (MVMCollectable **)&(args[i - 1].o));
num_roots++;
break;
case MVM_NATIVECALL_ARG_CPPSTRUCT:
args[i - 1].o = MVM_nativecall_make_cppstruct(tc, type, *(void **)cb_args[i - 1]);
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, *(void **)cb_args[i - 1]);
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, *(void **)cb_args[i - 1]);
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, *(void **)cb_args[i - 1]);
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. */
/* XXX do something with the function pointer: *(void **)cb_args[i - 1] */
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 = *(unsigned char *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_USHORT:
args[i - 1].i64 = *(unsigned short *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_UINT:
args[i - 1].i64 = *(unsigned int *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_ULONG:
args[i - 1].i64 = *(unsigned long *)cb_args[i - 1];
break;
case MVM_NATIVECALL_ARG_ULONGLONG:
args[i - 1].i64 = *(unsigned long long *)cb_args[i - 1];
break;
default:
MVM_telemetry_interval_stop(tc, interval_id, "nativecall callback handler failed");
MVM_exception_throw_adhoc(tc,
"Internal error: unhandled libffi 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 = MVM_frame_force_to_heap(tc, tc->cur_frame);
MVMFrame *backup_thread_entry_frame = tc->thread_entry_frame;
void **backup_jit_return_address = tc->jit_return_address;
tc->jit_return_address = NULL;
MVMROOT2(tc, backup_cur_frame, backup_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->current_frame_nr = backup_cur_frame->sequence_nr;
tc->thread_entry_frame = backup_thread_entry_frame;
tc->jit_return_address = backup_jit_return_address;
memcpy(tc->interp_jump, backup_interp_jump, sizeof(jmp_buf));
MVM_gc_root_temp_mark_reset(tc, backup_mark);
});
}
/* 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;
MVMuint64 num_attrs, i;
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, 2, 2);
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)->header), 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 = MVM_malloc(sizeof(MVMObject *));
MVM_ASSIGN_REF(tc, &(STABLE(type_obj)->header), STABLE(type_obj)->type_check_cache[0], type_obj);
attributes = ((MVMKnowHOWREPR *)self)->body.attributes;
/* Next steps will allocate, so make sure we keep hold of the type
* object and ourself. */
MVM_gc_root_temp_push(tc, (MVMCollectable **)&attributes);
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 = instance->boot_types.BOOTArray;
BOOTHash = 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);
/* ...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);
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);
MVM_repr_push_o(tc, type_info, attr_info_list);
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);
MVMROOT(tc, attr_info, {
MVMROOT(tc, attribute, {
if (REPR((MVMObject *)attribute)->ID != MVM_REPR_ID_KnowHOWAttributeREPR)
MVM_exception_throw_adhoc(tc, "KnowHOW attributes must use KnowHOWAttributeREPR");
MVM_repr_init(tc, attr_info);
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.name, (MVMObject *)attribute->body.name);
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.type, attribute->body.type);
if (attribute->body.box_target) {
/* Merely having the key serves as a "yes". */
MVM_repr_bind_key_o(tc, attr_info, instance->str_consts.box_target, attr_info);
}
MVM_repr_push_o(tc, attr_info_list, attr_info);
});
});
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]);
}
/* 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;
}
/* 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;
}