[svn:parrot] r48348 - in branches/gsoc_instrument: src/dynpmc tools/build
khairul at svn.parrot.org
khairul at svn.parrot.org
Sun Aug 8 16:38:08 UTC 2010
Author: khairul
Date: Sun Aug 8 16:38:07 2010
New Revision: 48348
URL: https://trac.parrot.org/parrot/changeset/48348
Log:
Updated stub generators and regenerated stubs.
Modified:
branches/gsoc_instrument/src/dynpmc/instrumentclass.pmc
branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
branches/gsoc_instrument/tools/build/gen_gc_stubs.pl (contents, props changed)
branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
Modified: branches/gsoc_instrument/src/dynpmc/instrumentclass.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentclass.pmc Sun Aug 8 16:36:50 2010 (r48347)
+++ branches/gsoc_instrument/src/dynpmc/instrumentclass.pmc Sun Aug 8 16:38:07 2010 (r48348)
@@ -8,10 +8,8 @@
=head1 DESCRIPTION
-C<InstrumentClass> extends InstrumentVtable and provides methods to
-instrument a class's methods. Generally methods are invokables, so
-to know when a method is called, simply instrumenting the invoke vtable
-entry of the method is enough.
+C<InstrumentClass> provides methods to instrument a class's methods
+and vtables.
=head2 Methods
@@ -21,11 +19,62 @@
*/
-#include "pmc_instrument.h"
+#include "parrot/parrot.h"
+
#include "pmc/pmc_class.h"
+#include "pmc_instrument.h"
+
+#include "instrument_private.h"
+#include "instrument_extern.h"
-pmclass InstrumentClass auto_attrs dynpmc group instrument_group extends InstrumentVtable {
- ATTR PMC *instrumented_methods;
+/* Macros for stubs. */
+#define VTABLE_STUB_VARS \
+ PMC *instrument, *instrumentvt, *params, *data, *event_array, *recall; \
+ Parrot_Interp supervisor; \
+ STRING *raise_event, *event; \
+ void *orig_vtable;
+
+#define VTABLE_STUB_SETUP \
+ instrumentvt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable); \
+ GETATTR_InstrumentClass_original_struct(interp, instrumentvt, orig_vtable); \
+ GETATTR_InstrumentClass_supervisor(interp, instrumentvt, supervisor); \
+ GETATTR_InstrumentClass_event_prefix(interp, instrumentvt, event_array); \
+ GETATTR_InstrumentClass_instrument(interp, instrumentvt, instrument); \
+ raise_event = CONST_STRING(supervisor, "raise_event"); \
+ event_array = VTABLE_clone(supervisor, event_array);
+
+#define VTABLE_STUB_CALL_PRE \
+ data = Parrot_pmc_new(supervisor, enum_class_Hash); \
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "parameters"), params); \
+ event = Parrot_str_join(supervisor, CONST_STRING(supervisor, "::"), event_array); \
+ Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, "SP->P", \
+ event, data, &recall);
+
+#define VTABLE_STUB_CALL_POST \
+ Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, "SPP->P", \
+ event, data, recall, &recall); \
+ probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+
+/* Helper Prototypes. */
+void setup_vtable_common_hashes(PARROT_INTERP);
+void destroy_vtable_common_hashes(PARROT_INTERP);
+void setup_vtable_individual_hashes(PARROT_INTERP, Hash *orig_hash, Hash *instr_hash,
+ _vtable *vt_orig, _vtable *vt_instr);
+
+/* Globals used internally. */
+static INTVAL vtable_first_run = 1;
+static Hash *vtable_registry = NULL;
+static Hash *vtable_name_stubs = NULL;
+static Hash *vtable_group_items = NULL;
+static Hash *vtable_item_groups = NULL;
+
+pmclass InstrumentClass auto_attrs dynpmc group instrument_group extends InstrumentStubBase {
+ ATTR size_t class_index;
+ ATTR STRING *class_name;
+ ATTR Parrot_Interp supervisor;
+ ATTR PMC *rename_hash;
+ ATTR PMC *vtable_overrides;
+ ATTR PMC *instrumented_methods;
/*
@@ -42,11 +91,279 @@
Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
SUPER(instrument);
+ /* Initialise the attributes.
+ Other attributes are deferred to after attaching to a class. */
+ attr->supervisor = INTERP;
+ attr->rename_hash = Parrot_pmc_new(INTERP, enum_class_Hash);
+ attr->vtable_overrides = Parrot_pmc_new(INTERP, enum_class_Hash);
+
+ /* Initialise the static hashes. */
+ setup_vtable_common_hashes(INTERP);
+
+ /* Update the attributes to point to the static hashes. */
+ attr->registry = vtable_registry;
+ attr->name_stubs = vtable_name_stubs;
+ attr->group_items = vtable_group_items;
+ attr->item_groups = vtable_item_groups;
+
attr->instrumented_methods = Parrot_pmc_new(INTERP, enum_class_Hash);
}
/*
+=item C<void destroy()>
+
+Cleanup internal data structures.
+
+=cut
+
+*/
+
+ VTABLE void destroy() {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ SUPER();
+ if (attr->instrumented_struct != NULL) {
+ parrot_hash_delete(INTERP, vtable_registry, attr->instrumented_struct);
+ }
+ destroy_vtable_common_hashes(INTERP);
+ }
+
+/*
+
+=item C<void attach_to_class(STRING *classname)>
+
+Do a soft initialization. Store only the class_name attribute.
+This is to get around trying to attach to classes that does
+not exist when this call is made.
+The vtable pointer will be replaced the first time a hook is inserted.
+
+=cut
+
+*/
+
+ METHOD attach_to_class(STRING *classname) {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ attr->class_name = classname;
+ }
+
+/*
+
+=item C<void _instrument_vtable()>
+
+Tries to instrument the class given by attr->class_name, which is set
+by attach_to_class. Throws an exception if this fails.
+
+For internal use only.
+
+=cut
+
+*/
+
+ METHOD _instrument_vtable() {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ Parrot_Interp supervised;
+
+ if (attr->class_index != 0) {
+ RETURN(void);
+ }
+
+ GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
+
+ /* class_index must not be 0. (0 = default). */
+ attr->class_index = Parrot_pmc_get_type_str(supervised, attr->class_name);
+ if (attr->class_index == 0) {
+ Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
+ "%Ss : Class not found, '%Ss'",
+ VTABLE_name(INTERP, SELF), attr->class_name);
+ }
+ attr->original_struct = supervised->vtables[attr->class_index];
+
+ /* Prepare the class's vtable for instrumentation. */
+ attr->instrumented_struct = mem_gc_allocate_zeroed_typed(supervised, _vtable);
+ mem_copy_n_typed(attr->instrumented_struct, attr->original_struct, 1, _vtable);
+ supervised->vtables[attr->class_index] = (_vtable *) attr->instrumented_struct;
+
+ /* Register the instrumented vtable to SELF. */
+ parrot_hash_put(INTERP, attr->registry, attr->instrumented_struct, SELF);
+
+ /* Build the vtable hashes, passing a sample vtable to build the offsets. */
+ setup_vtable_individual_hashes(INTERP, attr->name_original, attr->name_offset,
+ (_vtable *) attr->original_struct,
+ (_vtable *) attr->instrumented_struct);
+
+ /* Update the event_prefix attribute. */
+ VTABLE_push_string(INTERP, attr->event_prefix, CONST_STRING(INTERP, "Class"));
+ VTABLE_push_string(INTERP, attr->event_prefix, attr->class_name);
+ }
+
+/*
+
+=item C<void insert_hook(STRING *name)>
+
+Inserts the stub function for the entry given by name.
+If name denotes a group, inserts stubs for all functions in that group.
+
+=cut
+
+*/
+
+ METHOD insert_hook(STRING *name) {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ PMC *_class;
+ Parrot_Interp supervised;
+ PMC *list;
+ PMC *iter;
+ PMC *overrides;
+
+ /* Ensure class is instrumented. */
+ Parrot_pcc_invoke_method_from_c_args(INTERP, SELF,
+ CONST_STRING(INTERP, "_instrument_vtable"), "->");
+
+ GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
+ _class = Parrot_oo_get_class_str(supervised, attr->class_name);
+ GETATTR_Class_vtable_overrides(supervised, _class, overrides);
+
+ (PMC *list) = PCCINVOKE(INTERP, SELF, "get_hook_list", STRING *name);
+
+ iter = VTABLE_get_iter(INTERP, list);
+ while (VTABLE_get_bool(INTERP, iter)) {
+ INTVAL count;
+ PMC *item_pmc = VTABLE_shift_pmc(INTERP, iter);
+ STRING *item = VTABLE_get_string(INTERP, item_pmc);
+ size_t **entry, *func;
+
+ /* Check if the entry has already been instrumented. */
+ count = VTABLE_get_integer_keyed_str(INTERP, attr->hook_count, item);
+ if (count == 0) {
+ /* Look for a vtable override. */
+ PMC *override;
+ override = VTABLE_get_pmc_keyed_str(supervised, overrides, item);
+
+ if (PMC_IS_NULL(override)) {
+ /* No override. */
+ /* Replace the entry with the stub. */
+ entry = (size_t **) parrot_hash_get(INTERP, attr->name_offset, item);
+ func = (size_t *) parrot_hash_get(INTERP, attr->name_stubs, item);
+ if (entry == NULL || func == NULL) {
+ Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
+ "%Ss : Unknown function, '%Ss'",
+ VTABLE_name(INTERP, SELF), item);
+ }
+ *entry = func;
+ }
+ else {
+ /* It appears that there is a vtable override.
+ Instrument the invoke vtable entry of the override.
+ (which is assumed to be invokable, otherwise it won't be much
+ of an override.) */
+ PMC *invokable, *event;
+ STRING *group;
+ INTVAL type;
+
+ type = Parrot_pmc_get_type_str(INTERP, CONST_STRING(INTERP, "InstrumentInvokable"));
+ invokable= Parrot_pmc_new_init(INTERP, type, attr->instrument);
+
+ (STRING *group) = PCCINVOKE(INTERP, SELF, "get_hook_group", STRING *item);
+
+ event = VTABLE_clone(INTERP, attr->event_prefix);
+ VTABLE_push_string(INTERP, event, CONST_STRING(INTERP, "vtable"));
+ VTABLE_push_string(INTERP, event, group);
+ VTABLE_push_string(INTERP, event, item);
+
+ () = PCCINVOKE(INTERP, invokable, "set_event", PMC *event);
+
+ VTABLE_set_pointer(INTERP, invokable, override);
+
+ VTABLE_set_pmc_keyed_str(supervised, overrides, item, invokable);
+ }
+ }
+
+ /* Update the count. */
+ count++;
+ VTABLE_set_integer_keyed_str(INTERP, attr->hook_count, item, count);
+ }
+ }
+
+/*
+
+=item C<void remove_hook(STRING *name)>
+
+Removes the stub function for the given entry given by name.
+If name denotes a group, removes stubs for all functions in that group.
+
+=cut
+
+*/
+
+ METHOD remove_hook(STRING *name) {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ PMC *list;
+ PMC *iter;
+ PMC *_class;
+ Parrot_Interp supervised;
+ PMC *overrides;
+
+ /* Ensure class is instrumented. */
+ Parrot_pcc_invoke_method_from_c_args(INTERP, SELF,
+ CONST_STRING(INTERP, "_instrument_vtable"), "->");
+
+ GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
+ _class = Parrot_oo_get_class_str(supervised, attr->class_name);
+ GETATTR_Class_vtable_overrides(supervised, _class, overrides);
+
+ (PMC *list) = PCCINVOKE(INTERP, SELF, "get_hook_list", STRING *name);
+
+ iter = VTABLE_get_iter(INTERP, list);
+ while (VTABLE_get_bool(INTERP, iter)) {
+ INTVAL count;
+ PMC *item_pmc = VTABLE_shift_pmc(INTERP, iter);
+ STRING *item = VTABLE_get_string(INTERP, item_pmc);
+ size_t **entry, *func;
+
+ /* Only remove the stub if request count == 1 => Last request. */
+ count = VTABLE_get_integer_keyed_str(INTERP, attr->hook_count, item);
+ if (count <= 0) {
+ /* Tried to remove 1 time too many. */
+ Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
+ "%Ss : Unknown function, '%Ss'",
+ VTABLE_name(INTERP, SELF), item);
+ }
+ else if (count == 1) {
+ /* Look for a vtable override. */
+ PMC *override;
+ override = Parrot_oo_find_vtable_override_for_class(supervised, _class, name);
+
+ if (PMC_IS_NULL(override)) {
+ /* No override. */
+ /* Simply replace the stub with the original entry. */
+ entry = (size_t **) parrot_hash_get(INTERP, attr->name_offset, item);
+ func = (size_t *) parrot_hash_get(INTERP, attr->name_original, item);
+ if (entry == NULL || func == NULL) {
+ Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
+ "%Ss : Unknown function, '%Ss'",
+ VTABLE_name(INTERP, SELF), item);
+ }
+ *entry = func;
+ }
+ else {
+ /* It appears that there is a vtable override.
+ Remove the instrumentation of the override's invoke
+ vtable entry. */
+ PMC *orig_vtable_sub;
+
+ orig_vtable_sub = (PMC *) VTABLE_get_pointer(INTERP, override);
+ VTABLE_set_pmc_keyed_str(supervised, overrides, item, orig_vtable_sub);
+ }
+ }
+
+ /* Update the count. */
+ count--;
+ VTABLE_set_integer_keyed_str(INTERP, attr->hook_count, item, count);
+ }
+ }
+
+/*
+
=item C<PMC* get_method_list()>
Returns a list of methods in the class that InstrumentClass is attached to.
@@ -62,6 +379,10 @@
PMC *iter;
Parrot_Interp supervised;
+ /* Ensure class is instrumented. */
+ Parrot_pcc_invoke_method_from_c_args(INTERP, SELF,
+ CONST_STRING(INTERP, "_instrument_vtable"), "->");
+
GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
_class = Parrot_oo_get_class_str(supervised, attr->class_name);
@@ -99,6 +420,10 @@
INTVAL count;
Parrot_Interp supervised;
+ /* Ensure class is instrumented. */
+ Parrot_pcc_invoke_method_from_c_args(INTERP, SELF,
+ CONST_STRING(INTERP, "_instrument_vtable"), "->");
+
invoke = CONST_STRING(INTERP, "invoke");
GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
@@ -158,6 +483,10 @@
INTVAL count;
Parrot_Interp supervised;
+ /* Ensure class is instrumented. */
+ Parrot_pcc_invoke_method_from_c_args(INTERP, SELF,
+ CONST_STRING(INTERP, "_instrument_vtable"), "->");
+
GETATTR_Instrument_supervised(INTERP, attr->instrument, supervised);
_class = Parrot_oo_get_class_str(supervised, attr->class_name);
@@ -223,8 +552,4809 @@
RETURN(PMC *list);
}
+
+/*
+
+=item C<STRING* get_classname()>
+
+Returns the name of the class associated with this instances.
+
+=cut
+
+*/
+
+ METHOD get_classname() {
+ Parrot_InstrumentClass_attributes * const attr = PARROT_INSTRUMENTCLASS(SELF);
+ STRING *name = attr->class_name;
+ RETURN(STRING *name);
+ }
+}
+
+/* BELOW LIES GENERATED CODE GENERATED BY tools/build/gen_vtable_stubs.pl */
+/* Stub Prototypes */
+/* BEGIN vtable prototypes */
+static PMC* stub_absolute(PARROT_INTERP, PMC *pmc, PMC* dest);
+static PMC* stub_add(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static void stub_add_attribute(PARROT_INTERP, PMC *pmc, STRING* name, PMC* type);
+static PMC* stub_add_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_add_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static void stub_add_method(PARROT_INTERP, PMC *pmc, STRING* method_name, PMC* sub_pmc);
+static void stub_add_parent(PARROT_INTERP, PMC *pmc, PMC* parent);
+static void stub_add_role(PARROT_INTERP, PMC *pmc, PMC* role);
+static void stub_add_vtable_override(PARROT_INTERP, PMC *pmc, STRING* vtable_name, PMC* sub_pmc);
+static void stub_assign_pmc(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_assign_string_native(PARROT_INTERP, PMC *pmc, STRING* value);
+static INTVAL stub_can(PARROT_INTERP, PMC *pmc, STRING* method);
+static PMC* stub_clone(PARROT_INTERP, PMC *pmc);
+static PMC* stub_clone_pmc(PARROT_INTERP, PMC *pmc, PMC* args);
+static INTVAL stub_cmp(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_cmp_num(PARROT_INTERP, PMC *pmc, PMC* value);
+static PMC* stub_cmp_pmc(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_cmp_string(PARROT_INTERP, PMC *pmc, PMC* value);
+static PMC* stub_concatenate(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_concatenate_str(PARROT_INTERP, PMC *pmc, STRING* value, PMC* dest);
+static void stub_decrement(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_defined(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_defined_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static INTVAL stub_defined_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static INTVAL stub_defined_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static void stub_delete_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static void stub_delete_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static void stub_delete_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static void stub_delprop(PARROT_INTERP, PMC *pmc, STRING* key);
+static void stub_destroy(PARROT_INTERP, PMC *pmc);
+static PMC* stub_divide(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static INTVAL stub_does(PARROT_INTERP, PMC *pmc, STRING* role);
+static INTVAL stub_does_pmc(PARROT_INTERP, PMC *pmc, PMC* role);
+static INTVAL stub_elements(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_exists_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static INTVAL stub_exists_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static INTVAL stub_exists_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static PMC* stub_find_method(PARROT_INTERP, PMC *pmc, STRING* method_name);
+static PMC* stub_floor_divide(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_floor_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_floor_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static void stub_freeze(PARROT_INTERP, PMC *pmc, PMC* info);
+static PMC* stub_get_attr_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* idx);
+static PMC* stub_get_attr_str(PARROT_INTERP, PMC *pmc, STRING* idx);
+static INTVAL stub_get_bool(PARROT_INTERP, PMC *pmc);
+static PMC* stub_get_class(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_get_integer(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static PMC* stub_get_iter(PARROT_INTERP, PMC *pmc);
+static PMC* stub_get_namespace(PARROT_INTERP, PMC *pmc);
+static FLOATVAL stub_get_number(PARROT_INTERP, PMC *pmc);
+static FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static PMC* stub_get_pmc(PARROT_INTERP, PMC *pmc);
+static PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static void* stub_get_pointer(PARROT_INTERP, PMC *pmc);
+static void* stub_get_pointer_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static STRING* stub_get_repr(PARROT_INTERP, PMC *pmc);
+static STRING* stub_get_string(PARROT_INTERP, PMC *pmc);
+static STRING* stub_get_string_keyed(PARROT_INTERP, PMC *pmc, PMC* key);
+static STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key);
+static STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key);
+static PMC* stub_getprop(PARROT_INTERP, PMC *pmc, STRING* key);
+static PMC* stub_getprops(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_hashvalue(PARROT_INTERP, PMC *pmc);
+static void stub_i_absolute(PARROT_INTERP, PMC *pmc);
+static void stub_i_add(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_add_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_add_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_concatenate(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_concatenate_str(PARROT_INTERP, PMC *pmc, STRING* value);
+static void stub_i_divide(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_floor_divide(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_floor_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_floor_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_logical_not(PARROT_INTERP, PMC *pmc);
+static void stub_i_modulus(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_modulus_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_modulus_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_multiply(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_multiply_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_multiply_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_neg(PARROT_INTERP, PMC *pmc);
+static void stub_i_repeat(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_repeat_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_i_subtract(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_i_subtract_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_i_subtract_int(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_increment(PARROT_INTERP, PMC *pmc);
+static void stub_init(PARROT_INTERP, PMC *pmc);
+static void stub_init_int(PARROT_INTERP, PMC *pmc, INTVAL initializer);
+static void stub_init_pmc(PARROT_INTERP, PMC *pmc, PMC* initializer);
+static PMC* stub_inspect(PARROT_INTERP, PMC *pmc);
+static PMC* stub_inspect_str(PARROT_INTERP, PMC *pmc, STRING* what);
+static PMC* stub_instantiate(PARROT_INTERP, PMC *pmc, PMC* sig);
+static opcode_t* stub_invoke(PARROT_INTERP, PMC *pmc, void* next);
+static INTVAL stub_is_equal(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_is_equal_num(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_is_equal_string(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_is_same(PARROT_INTERP, PMC *pmc, PMC* value);
+static INTVAL stub_isa(PARROT_INTERP, PMC *pmc, STRING* _class);
+static INTVAL stub_isa_pmc(PARROT_INTERP, PMC *pmc, PMC* _class);
+static PMC* stub_logical_and(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_logical_not(PARROT_INTERP, PMC *pmc, PMC* dest);
+static PMC* stub_logical_or(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_logical_xor(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static void stub_mark(PARROT_INTERP, PMC *pmc);
+static PMC* stub_modulus(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_modulus_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_modulus_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static void stub_morph(PARROT_INTERP, PMC *pmc, PMC* type);
+static PMC* stub_multiply(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_multiply_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_multiply_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static STRING* stub_name(PARROT_INTERP, PMC *pmc);
+static PMC* stub_neg(PARROT_INTERP, PMC *pmc, PMC* dest);
+static FLOATVAL stub_pop_float(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_pop_integer(PARROT_INTERP, PMC *pmc);
+static PMC* stub_pop_pmc(PARROT_INTERP, PMC *pmc);
+static STRING* stub_pop_string(PARROT_INTERP, PMC *pmc);
+static void stub_push_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_push_integer(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_push_pmc(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_push_string(PARROT_INTERP, PMC *pmc, STRING* value);
+static void stub_remove_attribute(PARROT_INTERP, PMC *pmc, STRING* name);
+static void stub_remove_method(PARROT_INTERP, PMC *pmc, STRING* method_name);
+static void stub_remove_parent(PARROT_INTERP, PMC *pmc, PMC* parent);
+static void stub_remove_role(PARROT_INTERP, PMC *pmc, PMC* role);
+static void stub_remove_vtable_override(PARROT_INTERP, PMC *pmc, STRING* vtable_name);
+static PMC* stub_repeat(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_repeat_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static void stub_set_attr_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* idx, PMC* value);
+static void stub_set_attr_str(PARROT_INTERP, PMC *pmc, STRING* idx, PMC* value);
+static void stub_set_bool(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_set_integer_keyed(PARROT_INTERP, PMC *pmc, PMC* key, INTVAL value);
+static void stub_set_integer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, INTVAL value);
+static void stub_set_integer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, INTVAL value);
+static void stub_set_integer_native(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_set_number_keyed(PARROT_INTERP, PMC *pmc, PMC* key, FLOATVAL value);
+static void stub_set_number_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, FLOATVAL value);
+static void stub_set_number_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, FLOATVAL value);
+static void stub_set_number_native(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_set_pmc(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_set_pmc_keyed(PARROT_INTERP, PMC *pmc, PMC* key, PMC* value);
+static void stub_set_pmc_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, PMC* value);
+static void stub_set_pmc_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, PMC* value);
+static void stub_set_pointer(PARROT_INTERP, PMC *pmc, void* value);
+static void stub_set_pointer_keyed(PARROT_INTERP, PMC *pmc, PMC* key, void* value);
+static void stub_set_pointer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, void* value);
+static void stub_set_pointer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, void* value);
+static void stub_set_string_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* value);
+static void stub_set_string_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, STRING* value);
+static void stub_set_string_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, STRING* value);
+static void stub_set_string_native(PARROT_INTERP, PMC *pmc, STRING* value);
+static void stub_setprop(PARROT_INTERP, PMC *pmc, STRING* key, PMC* value);
+static void stub_share(PARROT_INTERP, PMC *pmc);
+static PMC* stub_share_ro(PARROT_INTERP, PMC *pmc);
+static FLOATVAL stub_shift_float(PARROT_INTERP, PMC *pmc);
+static INTVAL stub_shift_integer(PARROT_INTERP, PMC *pmc);
+static PMC* stub_shift_pmc(PARROT_INTERP, PMC *pmc);
+static STRING* stub_shift_string(PARROT_INTERP, PMC *pmc);
+static void stub_splice(PARROT_INTERP, PMC *pmc, PMC* value, INTVAL offset, INTVAL count);
+static void stub_substr(PARROT_INTERP, PMC *pmc, INTVAL offset, INTVAL length, PMC* dest);
+static STRING* stub_substr_str(PARROT_INTERP, PMC *pmc, INTVAL offset, INTVAL length);
+static PMC* stub_subtract(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest);
+static PMC* stub_subtract_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest);
+static PMC* stub_subtract_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest);
+static void stub_thaw(PARROT_INTERP, PMC *pmc, PMC* info);
+static void stub_thawfinish(PARROT_INTERP, PMC *pmc, PMC* info);
+static INTVAL stub_type(PARROT_INTERP, PMC *pmc);
+static void stub_unshift_float(PARROT_INTERP, PMC *pmc, FLOATVAL value);
+static void stub_unshift_integer(PARROT_INTERP, PMC *pmc, INTVAL value);
+static void stub_unshift_pmc(PARROT_INTERP, PMC *pmc, PMC* value);
+static void stub_unshift_string(PARROT_INTERP, PMC *pmc, STRING* value);
+static void stub_visit(PARROT_INTERP, PMC *pmc, PMC* info);
+/* END vtable prototypes */
+
+void setup_vtable_common_hashes(PARROT_INTERP) {
+ PMC *temp;
+ if (!vtable_first_run) return;
+
+ vtable_first_run = 0;
+ vtable_registry = parrot_new_pointer_hash(interp);
+ vtable_name_stubs = parrot_new_hash(interp);
+ vtable_group_items = parrot_new_hash(interp);
+ vtable_item_groups = parrot_new_hash(interp);
+
+ /* BEGIN vtable mapping name stubs */
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "absolute"), stub_absolute);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add"), stub_add);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_attribute"), stub_add_attribute);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_float"), stub_add_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_int"), stub_add_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_method"), stub_add_method);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_parent"), stub_add_parent);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_role"), stub_add_role);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "add_vtable_override"), stub_add_vtable_override);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "assign_pmc"), stub_assign_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "assign_string_native"), stub_assign_string_native);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "can"), stub_can);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "clone"), stub_clone);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "clone_pmc"), stub_clone_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "cmp"), stub_cmp);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "cmp_num"), stub_cmp_num);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "cmp_pmc"), stub_cmp_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "cmp_string"), stub_cmp_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "concatenate"), stub_concatenate);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "concatenate_str"), stub_concatenate_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "decrement"), stub_decrement);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "defined"), stub_defined);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "defined_keyed"), stub_defined_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "defined_keyed_int"), stub_defined_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "defined_keyed_str"), stub_defined_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "delete_keyed"), stub_delete_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "delete_keyed_int"), stub_delete_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "delete_keyed_str"), stub_delete_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "delprop"), stub_delprop);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "destroy"), stub_destroy);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "divide"), stub_divide);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "divide_float"), stub_divide_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "divide_int"), stub_divide_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "does"), stub_does);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "does_pmc"), stub_does_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "elements"), stub_elements);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "exists_keyed"), stub_exists_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "exists_keyed_int"), stub_exists_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "exists_keyed_str"), stub_exists_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "find_method"), stub_find_method);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "floor_divide"), stub_floor_divide);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "floor_divide_float"), stub_floor_divide_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "floor_divide_int"), stub_floor_divide_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "freeze"), stub_freeze);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_attr_keyed"), stub_get_attr_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_attr_str"), stub_get_attr_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_bool"), stub_get_bool);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_class"), stub_get_class);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_integer"), stub_get_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_integer_keyed"), stub_get_integer_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_integer_keyed_int"), stub_get_integer_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_integer_keyed_str"), stub_get_integer_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_iter"), stub_get_iter);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_namespace"), stub_get_namespace);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_number"), stub_get_number);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_number_keyed"), stub_get_number_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_number_keyed_int"), stub_get_number_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_number_keyed_str"), stub_get_number_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pmc"), stub_get_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pmc_keyed"), stub_get_pmc_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pmc_keyed_int"), stub_get_pmc_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pmc_keyed_str"), stub_get_pmc_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pointer"), stub_get_pointer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pointer_keyed"), stub_get_pointer_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pointer_keyed_int"), stub_get_pointer_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pointer_keyed_str"), stub_get_pointer_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_repr"), stub_get_repr);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_string"), stub_get_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_string_keyed"), stub_get_string_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_string_keyed_int"), stub_get_string_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_string_keyed_str"), stub_get_string_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "getprop"), stub_getprop);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "getprops"), stub_getprops);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "hashvalue"), stub_hashvalue);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_absolute"), stub_i_absolute);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_add"), stub_i_add);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_add_float"), stub_i_add_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_add_int"), stub_i_add_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_concatenate"), stub_i_concatenate);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_concatenate_str"), stub_i_concatenate_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_divide"), stub_i_divide);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_divide_float"), stub_i_divide_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_divide_int"), stub_i_divide_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_floor_divide"), stub_i_floor_divide);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_floor_divide_float"), stub_i_floor_divide_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_floor_divide_int"), stub_i_floor_divide_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_logical_not"), stub_i_logical_not);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_modulus"), stub_i_modulus);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_modulus_float"), stub_i_modulus_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_modulus_int"), stub_i_modulus_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_multiply"), stub_i_multiply);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_multiply_float"), stub_i_multiply_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_multiply_int"), stub_i_multiply_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_neg"), stub_i_neg);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_repeat"), stub_i_repeat);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_repeat_int"), stub_i_repeat_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_subtract"), stub_i_subtract);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_subtract_float"), stub_i_subtract_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_subtract_int"), stub_i_subtract_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "increment"), stub_increment);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "init"), stub_init);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "init_int"), stub_init_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "init_pmc"), stub_init_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "inspect"), stub_inspect);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "inspect_str"), stub_inspect_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "instantiate"), stub_instantiate);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "invoke"), stub_invoke);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "is_equal"), stub_is_equal);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "is_equal_num"), stub_is_equal_num);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "is_equal_string"), stub_is_equal_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "is_same"), stub_is_same);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "isa"), stub_isa);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "isa_pmc"), stub_isa_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "logical_and"), stub_logical_and);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "logical_not"), stub_logical_not);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "logical_or"), stub_logical_or);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "logical_xor"), stub_logical_xor);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "mark"), stub_mark);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "modulus"), stub_modulus);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "modulus_float"), stub_modulus_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "modulus_int"), stub_modulus_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "morph"), stub_morph);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "multiply"), stub_multiply);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "multiply_float"), stub_multiply_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "multiply_int"), stub_multiply_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "name"), stub_name);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "neg"), stub_neg);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_float"), stub_pop_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_integer"), stub_pop_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_pmc"), stub_pop_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_string"), stub_pop_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "push_float"), stub_push_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "push_integer"), stub_push_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "push_pmc"), stub_push_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "push_string"), stub_push_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "remove_attribute"), stub_remove_attribute);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "remove_method"), stub_remove_method);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "remove_parent"), stub_remove_parent);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "remove_role"), stub_remove_role);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "remove_vtable_override"), stub_remove_vtable_override);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "repeat"), stub_repeat);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "repeat_int"), stub_repeat_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_attr_keyed"), stub_set_attr_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_attr_str"), stub_set_attr_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_bool"), stub_set_bool);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_integer_keyed"), stub_set_integer_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_integer_keyed_int"), stub_set_integer_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_integer_keyed_str"), stub_set_integer_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_integer_native"), stub_set_integer_native);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_number_keyed"), stub_set_number_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_number_keyed_int"), stub_set_number_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_number_keyed_str"), stub_set_number_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_number_native"), stub_set_number_native);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pmc"), stub_set_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pmc_keyed"), stub_set_pmc_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pmc_keyed_int"), stub_set_pmc_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pmc_keyed_str"), stub_set_pmc_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pointer"), stub_set_pointer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pointer_keyed"), stub_set_pointer_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pointer_keyed_int"), stub_set_pointer_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_pointer_keyed_str"), stub_set_pointer_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_string_keyed"), stub_set_string_keyed);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_string_keyed_int"), stub_set_string_keyed_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_string_keyed_str"), stub_set_string_keyed_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "set_string_native"), stub_set_string_native);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "setprop"), stub_setprop);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "share"), stub_share);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "share_ro"), stub_share_ro);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_float"), stub_shift_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_integer"), stub_shift_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_pmc"), stub_shift_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_string"), stub_shift_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "splice"), stub_splice);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "substr"), stub_substr);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "substr_str"), stub_substr_str);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "subtract"), stub_subtract);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "subtract_float"), stub_subtract_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "subtract_int"), stub_subtract_int);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "thaw"), stub_thaw);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "thawfinish"), stub_thawfinish);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "type"), stub_type);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "unshift_float"), stub_unshift_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "unshift_integer"), stub_unshift_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "unshift_pmc"), stub_unshift_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "unshift_string"), stub_unshift_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "visit"), stub_visit);
+ /* END vtable mapping name stubs */
+
+ /* BEGIN vtable mapping group items */
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "assign_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "assign_string_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_bool"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_native"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "store"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "absolute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "decrement"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_absolute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_neg"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "increment"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "neg"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract_int"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "math"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "concatenate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "concatenate_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_concatenate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_concatenate_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_repeat"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_repeat_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "repeat"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "repeat_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "substr"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "substr_str"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "string"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "absolute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_attribute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_parent"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_role"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_vtable_override"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "assign_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "assign_string_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "can"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "clone"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "clone_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_num"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "concatenate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "concatenate_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "decrement"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "destroy"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "does"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "does_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "elements"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "find_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "floor_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "freeze"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_attr_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_attr_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_bool"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_class"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_iter"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_namespace"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_repr"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "getprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "getprops"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "hashvalue"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_absolute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_add_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_concatenate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_concatenate_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_floor_divide_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_logical_not"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_modulus_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_multiply_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_neg"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_repeat"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_repeat_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_subtract_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "increment"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "inspect"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "inspect_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "instantiate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "invoke"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal_num"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_same"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "isa"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "isa_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_and"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_not"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_or"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_xor"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "mark"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "modulus_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "morph"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "multiply_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "name"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "neg"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_attribute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_parent"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_role"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_vtable_override"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "repeat"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "repeat_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_attr_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_attr_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_bool"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_integer_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_number_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_string_native"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "setprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "share"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "share_ro"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "splice"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "substr"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "substr_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "subtract_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "thaw"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "thawfinish"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "type"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "visit"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "all"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_attribute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_parent"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_role"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "add_vtable_override"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "can"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "clone"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "clone_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "defined_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "destroy"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "does"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "does_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "find_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "freeze"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_attr_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_attr_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_class"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_iter"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_namespace"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "getprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "getprops"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "hashvalue"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "init_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "inspect"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "inspect_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "instantiate"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "invoke"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "isa"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "isa_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "mark"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "morph"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "name"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_attribute"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_method"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_parent"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_role"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "remove_vtable_override"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_attr_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "set_attr_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "setprop"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "share"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "share_ro"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "thaw"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "thawfinish"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "type"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "visit"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "main"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "push_string"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "push"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_num"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "cmp_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "i_logical_not"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal_num"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_equal_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "is_same"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_and"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_not"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_or"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "logical_xor"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "cmp"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "splice"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "splice"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "unshift_string"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "unshift"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "shift_string"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "shift"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "delete_keyed_str"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "delete"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "elements"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "fetchsize"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "exists_keyed_str"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "exists"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_bool"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_integer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_number_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_repr"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed_int"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "get_string_keyed_str"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "fetch"), temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_float"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_integer"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_pmc"));
+ VTABLE_push_string(interp, temp, CONST_STRING(interp, "pop_string"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "pop"), temp);
+ /* END vtable mapping group items */
+
+ /* BEGIN vtable mapping item groups */
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "absolute"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_attribute"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_method"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_parent"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_role"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "add_vtable_override"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "assign_pmc"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "assign_string_native"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "can"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "clone"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "clone_pmc"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "cmp"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "cmp_num"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "cmp_pmc"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "cmp_string"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "concatenate"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "concatenate_str"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "decrement"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "defined"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "defined_keyed"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "defined_keyed_int"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "defined_keyed_str"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "delete_keyed"),
+ CONST_STRING(interp, "delete"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "delete_keyed_int"),
+ CONST_STRING(interp, "delete"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "delete_keyed_str"),
+ CONST_STRING(interp, "delete"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "delprop"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "destroy"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "divide"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "divide_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "divide_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "does"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "does_pmc"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "elements"),
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "exists_keyed"),
+ CONST_STRING(interp, "exists"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "exists_keyed_int"),
+ CONST_STRING(interp, "exists"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "exists_keyed_str"),
+ CONST_STRING(interp, "exists"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "find_method"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "floor_divide"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "floor_divide_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "floor_divide_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "freeze"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_attr_keyed"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_attr_str"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_bool"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_class"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_integer"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_integer_keyed"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_integer_keyed_int"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_integer_keyed_str"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_iter"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_namespace"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_number"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_number_keyed"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_number_keyed_int"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_number_keyed_str"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pmc"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pmc_keyed"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pmc_keyed_int"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pmc_keyed_str"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pointer"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pointer_keyed"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pointer_keyed_int"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_pointer_keyed_str"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_repr"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_string"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_string_keyed"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_string_keyed_int"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "get_string_keyed_str"),
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "getprop"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "getprops"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "hashvalue"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_absolute"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_add"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_add_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_add_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_concatenate"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_concatenate_str"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_divide"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_divide_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_divide_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_floor_divide"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_floor_divide_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_floor_divide_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_logical_not"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_modulus"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_modulus_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_modulus_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_multiply"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_multiply_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_multiply_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_neg"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_repeat"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_repeat_int"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_subtract"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_subtract_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "i_subtract_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "increment"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "init"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "init_int"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "init_pmc"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "inspect"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "inspect_str"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "instantiate"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "invoke"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "is_equal"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "is_equal_num"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "is_equal_string"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "is_same"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "isa"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "isa_pmc"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "logical_and"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "logical_not"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "logical_or"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "logical_xor"),
+ CONST_STRING(interp, "cmp"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "mark"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "modulus"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "modulus_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "modulus_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "morph"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "multiply"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "multiply_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "multiply_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "name"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "neg"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "pop_float"),
+ CONST_STRING(interp, "pop"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "pop_integer"),
+ CONST_STRING(interp, "pop"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "pop_pmc"),
+ CONST_STRING(interp, "pop"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "pop_string"),
+ CONST_STRING(interp, "pop"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "push_float"),
+ CONST_STRING(interp, "push"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "push_integer"),
+ CONST_STRING(interp, "push"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "push_pmc"),
+ CONST_STRING(interp, "push"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "push_string"),
+ CONST_STRING(interp, "push"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "remove_attribute"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "remove_method"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "remove_parent"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "remove_role"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "remove_vtable_override"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "repeat"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "repeat_int"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_attr_keyed"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_attr_str"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_bool"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_integer_keyed"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_integer_keyed_int"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_integer_keyed_str"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_integer_native"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_number_keyed"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_number_keyed_int"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_number_keyed_str"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_number_native"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pmc"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pmc_keyed"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pmc_keyed_int"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pmc_keyed_str"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pointer"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pointer_keyed"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pointer_keyed_int"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_pointer_keyed_str"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_string_keyed"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_string_keyed_int"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_string_keyed_str"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "set_string_native"),
+ CONST_STRING(interp, "store"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "setprop"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "share"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "share_ro"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "shift_float"),
+ CONST_STRING(interp, "shift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "shift_integer"),
+ CONST_STRING(interp, "shift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "shift_pmc"),
+ CONST_STRING(interp, "shift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "shift_string"),
+ CONST_STRING(interp, "shift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "splice"),
+ CONST_STRING(interp, "splice"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "substr"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "substr_str"),
+ CONST_STRING(interp, "string"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "subtract"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "subtract_float"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "subtract_int"),
+ CONST_STRING(interp, "math"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "thaw"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "thawfinish"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "type"),
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "unshift_float"),
+ CONST_STRING(interp, "unshift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "unshift_integer"),
+ CONST_STRING(interp, "unshift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "unshift_pmc"),
+ CONST_STRING(interp, "unshift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "unshift_string"),
+ CONST_STRING(interp, "unshift"));
+ parrot_hash_put(interp, vtable_item_groups, CONST_STRING(interp, "visit"),
+ CONST_STRING(interp, "main"));
+ /* END vtable mapping item groups */
+}
+
+void destroy_vtable_common_hashes(PARROT_INTERP) {
+ if (vtable_registry == NULL) { return; }
+
+ if (parrot_hash_size(interp, vtable_registry) == 0) {
+ parrot_hash_destroy(interp, vtable_registry);
+ parrot_hash_destroy(interp, vtable_name_stubs);
+ parrot_hash_destroy(interp, vtable_group_items);
+ parrot_hash_destroy(interp, vtable_item_groups);
+
+ vtable_first_run = 1;
+ vtable_registry = NULL;
+ vtable_name_stubs = NULL;
+ vtable_group_items = NULL;
+ vtable_item_groups = NULL;
+ }
+}
+
+void setup_vtable_individual_hashes(PARROT_INTERP, Hash *orig_hash, Hash *instr_hash,
+ _vtable *vt_orig, _vtable *vt_instr) {
+ /* BEGIN vtable mapping name offset */
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "absolute"), &(vt_instr->absolute));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add"), &(vt_instr->add));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_attribute"), &(vt_instr->add_attribute));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_float"), &(vt_instr->add_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_int"), &(vt_instr->add_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_method"), &(vt_instr->add_method));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_parent"), &(vt_instr->add_parent));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_role"), &(vt_instr->add_role));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "add_vtable_override"), &(vt_instr->add_vtable_override));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "assign_pmc"), &(vt_instr->assign_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "assign_string_native"), &(vt_instr->assign_string_native));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "can"), &(vt_instr->can));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "clone"), &(vt_instr->clone));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "clone_pmc"), &(vt_instr->clone_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "cmp"), &(vt_instr->cmp));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "cmp_num"), &(vt_instr->cmp_num));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "cmp_pmc"), &(vt_instr->cmp_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "cmp_string"), &(vt_instr->cmp_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "concatenate"), &(vt_instr->concatenate));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "concatenate_str"), &(vt_instr->concatenate_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "decrement"), &(vt_instr->decrement));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "defined"), &(vt_instr->defined));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "defined_keyed"), &(vt_instr->defined_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "defined_keyed_int"), &(vt_instr->defined_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "defined_keyed_str"), &(vt_instr->defined_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "delete_keyed"), &(vt_instr->delete_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "delete_keyed_int"), &(vt_instr->delete_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "delete_keyed_str"), &(vt_instr->delete_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "delprop"), &(vt_instr->delprop));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "destroy"), &(vt_instr->destroy));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "divide"), &(vt_instr->divide));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "divide_float"), &(vt_instr->divide_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "divide_int"), &(vt_instr->divide_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "does"), &(vt_instr->does));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "does_pmc"), &(vt_instr->does_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "elements"), &(vt_instr->elements));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "exists_keyed"), &(vt_instr->exists_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "exists_keyed_int"), &(vt_instr->exists_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "exists_keyed_str"), &(vt_instr->exists_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "find_method"), &(vt_instr->find_method));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "floor_divide"), &(vt_instr->floor_divide));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "floor_divide_float"), &(vt_instr->floor_divide_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "floor_divide_int"), &(vt_instr->floor_divide_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "freeze"), &(vt_instr->freeze));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_attr_keyed"), &(vt_instr->get_attr_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_attr_str"), &(vt_instr->get_attr_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_bool"), &(vt_instr->get_bool));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_class"), &(vt_instr->get_class));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_integer"), &(vt_instr->get_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_integer_keyed"), &(vt_instr->get_integer_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_integer_keyed_int"), &(vt_instr->get_integer_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_integer_keyed_str"), &(vt_instr->get_integer_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_iter"), &(vt_instr->get_iter));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_namespace"), &(vt_instr->get_namespace));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_number"), &(vt_instr->get_number));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_number_keyed"), &(vt_instr->get_number_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_number_keyed_int"), &(vt_instr->get_number_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_number_keyed_str"), &(vt_instr->get_number_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pmc"), &(vt_instr->get_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pmc_keyed"), &(vt_instr->get_pmc_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pmc_keyed_int"), &(vt_instr->get_pmc_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pmc_keyed_str"), &(vt_instr->get_pmc_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pointer"), &(vt_instr->get_pointer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pointer_keyed"), &(vt_instr->get_pointer_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pointer_keyed_int"), &(vt_instr->get_pointer_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pointer_keyed_str"), &(vt_instr->get_pointer_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_repr"), &(vt_instr->get_repr));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_string"), &(vt_instr->get_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_string_keyed"), &(vt_instr->get_string_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_string_keyed_int"), &(vt_instr->get_string_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_string_keyed_str"), &(vt_instr->get_string_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "getprop"), &(vt_instr->getprop));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "getprops"), &(vt_instr->getprops));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "hashvalue"), &(vt_instr->hashvalue));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_absolute"), &(vt_instr->i_absolute));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_add"), &(vt_instr->i_add));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_add_float"), &(vt_instr->i_add_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_add_int"), &(vt_instr->i_add_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_concatenate"), &(vt_instr->i_concatenate));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_concatenate_str"), &(vt_instr->i_concatenate_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_divide"), &(vt_instr->i_divide));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_divide_float"), &(vt_instr->i_divide_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_divide_int"), &(vt_instr->i_divide_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_floor_divide"), &(vt_instr->i_floor_divide));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_floor_divide_float"), &(vt_instr->i_floor_divide_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_floor_divide_int"), &(vt_instr->i_floor_divide_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_logical_not"), &(vt_instr->i_logical_not));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_modulus"), &(vt_instr->i_modulus));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_modulus_float"), &(vt_instr->i_modulus_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_modulus_int"), &(vt_instr->i_modulus_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_multiply"), &(vt_instr->i_multiply));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_multiply_float"), &(vt_instr->i_multiply_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_multiply_int"), &(vt_instr->i_multiply_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_neg"), &(vt_instr->i_neg));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_repeat"), &(vt_instr->i_repeat));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_repeat_int"), &(vt_instr->i_repeat_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_subtract"), &(vt_instr->i_subtract));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_subtract_float"), &(vt_instr->i_subtract_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_subtract_int"), &(vt_instr->i_subtract_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "increment"), &(vt_instr->increment));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "init"), &(vt_instr->init));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "init_int"), &(vt_instr->init_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "init_pmc"), &(vt_instr->init_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "inspect"), &(vt_instr->inspect));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "inspect_str"), &(vt_instr->inspect_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "instantiate"), &(vt_instr->instantiate));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "invoke"), &(vt_instr->invoke));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "is_equal"), &(vt_instr->is_equal));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "is_equal_num"), &(vt_instr->is_equal_num));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "is_equal_string"), &(vt_instr->is_equal_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "is_same"), &(vt_instr->is_same));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "isa"), &(vt_instr->isa));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "isa_pmc"), &(vt_instr->isa_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "logical_and"), &(vt_instr->logical_and));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "logical_not"), &(vt_instr->logical_not));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "logical_or"), &(vt_instr->logical_or));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "logical_xor"), &(vt_instr->logical_xor));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "mark"), &(vt_instr->mark));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "modulus"), &(vt_instr->modulus));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "modulus_float"), &(vt_instr->modulus_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "modulus_int"), &(vt_instr->modulus_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "morph"), &(vt_instr->morph));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "multiply"), &(vt_instr->multiply));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "multiply_float"), &(vt_instr->multiply_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "multiply_int"), &(vt_instr->multiply_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "name"), &(vt_instr->name));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "neg"), &(vt_instr->neg));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_float"), &(vt_instr->pop_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_integer"), &(vt_instr->pop_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_pmc"), &(vt_instr->pop_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_string"), &(vt_instr->pop_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "push_float"), &(vt_instr->push_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "push_integer"), &(vt_instr->push_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "push_pmc"), &(vt_instr->push_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "push_string"), &(vt_instr->push_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "remove_attribute"), &(vt_instr->remove_attribute));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "remove_method"), &(vt_instr->remove_method));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "remove_parent"), &(vt_instr->remove_parent));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "remove_role"), &(vt_instr->remove_role));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "remove_vtable_override"), &(vt_instr->remove_vtable_override));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "repeat"), &(vt_instr->repeat));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "repeat_int"), &(vt_instr->repeat_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_attr_keyed"), &(vt_instr->set_attr_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_attr_str"), &(vt_instr->set_attr_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_bool"), &(vt_instr->set_bool));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_integer_keyed"), &(vt_instr->set_integer_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_integer_keyed_int"), &(vt_instr->set_integer_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_integer_keyed_str"), &(vt_instr->set_integer_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_integer_native"), &(vt_instr->set_integer_native));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_number_keyed"), &(vt_instr->set_number_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_number_keyed_int"), &(vt_instr->set_number_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_number_keyed_str"), &(vt_instr->set_number_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_number_native"), &(vt_instr->set_number_native));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pmc"), &(vt_instr->set_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pmc_keyed"), &(vt_instr->set_pmc_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pmc_keyed_int"), &(vt_instr->set_pmc_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pmc_keyed_str"), &(vt_instr->set_pmc_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pointer"), &(vt_instr->set_pointer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pointer_keyed"), &(vt_instr->set_pointer_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pointer_keyed_int"), &(vt_instr->set_pointer_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_pointer_keyed_str"), &(vt_instr->set_pointer_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_string_keyed"), &(vt_instr->set_string_keyed));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_string_keyed_int"), &(vt_instr->set_string_keyed_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_string_keyed_str"), &(vt_instr->set_string_keyed_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "set_string_native"), &(vt_instr->set_string_native));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "setprop"), &(vt_instr->setprop));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "share"), &(vt_instr->share));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "share_ro"), &(vt_instr->share_ro));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_float"), &(vt_instr->shift_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_integer"), &(vt_instr->shift_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_pmc"), &(vt_instr->shift_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_string"), &(vt_instr->shift_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "splice"), &(vt_instr->splice));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "substr"), &(vt_instr->substr));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "substr_str"), &(vt_instr->substr_str));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "subtract"), &(vt_instr->subtract));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "subtract_float"), &(vt_instr->subtract_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "subtract_int"), &(vt_instr->subtract_int));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "thaw"), &(vt_instr->thaw));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "thawfinish"), &(vt_instr->thawfinish));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "type"), &(vt_instr->type));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unshift_float"), &(vt_instr->unshift_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unshift_integer"), &(vt_instr->unshift_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unshift_pmc"), &(vt_instr->unshift_pmc));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unshift_string"), &(vt_instr->unshift_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "visit"), &(vt_instr->visit));
+ /* END vtable mapping name offset */
+
+ /* BEGIN vtable mapping name original */
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "absolute"), vt_orig->absolute);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add"), vt_orig->add);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_attribute"), vt_orig->add_attribute);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_float"), vt_orig->add_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_int"), vt_orig->add_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_method"), vt_orig->add_method);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_parent"), vt_orig->add_parent);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_role"), vt_orig->add_role);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "add_vtable_override"), vt_orig->add_vtable_override);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "assign_pmc"), vt_orig->assign_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "assign_string_native"), vt_orig->assign_string_native);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "can"), vt_orig->can);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "clone"), vt_orig->clone);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "clone_pmc"), vt_orig->clone_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "cmp"), vt_orig->cmp);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "cmp_num"), vt_orig->cmp_num);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "cmp_pmc"), vt_orig->cmp_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "cmp_string"), vt_orig->cmp_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "concatenate"), vt_orig->concatenate);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "concatenate_str"), vt_orig->concatenate_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "decrement"), vt_orig->decrement);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "defined"), vt_orig->defined);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "defined_keyed"), vt_orig->defined_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "defined_keyed_int"), vt_orig->defined_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "defined_keyed_str"), vt_orig->defined_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "delete_keyed"), vt_orig->delete_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "delete_keyed_int"), vt_orig->delete_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "delete_keyed_str"), vt_orig->delete_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "delprop"), vt_orig->delprop);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "destroy"), vt_orig->destroy);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "divide"), vt_orig->divide);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "divide_float"), vt_orig->divide_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "divide_int"), vt_orig->divide_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "does"), vt_orig->does);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "does_pmc"), vt_orig->does_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "elements"), vt_orig->elements);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "exists_keyed"), vt_orig->exists_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "exists_keyed_int"), vt_orig->exists_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "exists_keyed_str"), vt_orig->exists_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "find_method"), vt_orig->find_method);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "floor_divide"), vt_orig->floor_divide);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "floor_divide_float"), vt_orig->floor_divide_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "floor_divide_int"), vt_orig->floor_divide_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "freeze"), vt_orig->freeze);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_attr_keyed"), vt_orig->get_attr_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_attr_str"), vt_orig->get_attr_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_bool"), vt_orig->get_bool);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_class"), vt_orig->get_class);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_integer"), vt_orig->get_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_integer_keyed"), vt_orig->get_integer_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_integer_keyed_int"), vt_orig->get_integer_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_integer_keyed_str"), vt_orig->get_integer_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_iter"), vt_orig->get_iter);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_namespace"), vt_orig->get_namespace);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_number"), vt_orig->get_number);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_number_keyed"), vt_orig->get_number_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_number_keyed_int"), vt_orig->get_number_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_number_keyed_str"), vt_orig->get_number_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pmc"), vt_orig->get_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pmc_keyed"), vt_orig->get_pmc_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pmc_keyed_int"), vt_orig->get_pmc_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pmc_keyed_str"), vt_orig->get_pmc_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pointer"), vt_orig->get_pointer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pointer_keyed"), vt_orig->get_pointer_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pointer_keyed_int"), vt_orig->get_pointer_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pointer_keyed_str"), vt_orig->get_pointer_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_repr"), vt_orig->get_repr);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_string"), vt_orig->get_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_string_keyed"), vt_orig->get_string_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_string_keyed_int"), vt_orig->get_string_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_string_keyed_str"), vt_orig->get_string_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "getprop"), vt_orig->getprop);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "getprops"), vt_orig->getprops);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "hashvalue"), vt_orig->hashvalue);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_absolute"), vt_orig->i_absolute);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_add"), vt_orig->i_add);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_add_float"), vt_orig->i_add_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_add_int"), vt_orig->i_add_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_concatenate"), vt_orig->i_concatenate);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_concatenate_str"), vt_orig->i_concatenate_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_divide"), vt_orig->i_divide);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_divide_float"), vt_orig->i_divide_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_divide_int"), vt_orig->i_divide_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_floor_divide"), vt_orig->i_floor_divide);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_floor_divide_float"), vt_orig->i_floor_divide_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_floor_divide_int"), vt_orig->i_floor_divide_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_logical_not"), vt_orig->i_logical_not);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_modulus"), vt_orig->i_modulus);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_modulus_float"), vt_orig->i_modulus_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_modulus_int"), vt_orig->i_modulus_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_multiply"), vt_orig->i_multiply);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_multiply_float"), vt_orig->i_multiply_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_multiply_int"), vt_orig->i_multiply_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_neg"), vt_orig->i_neg);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_repeat"), vt_orig->i_repeat);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_repeat_int"), vt_orig->i_repeat_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_subtract"), vt_orig->i_subtract);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_subtract_float"), vt_orig->i_subtract_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_subtract_int"), vt_orig->i_subtract_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "increment"), vt_orig->increment);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "init"), vt_orig->init);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "init_int"), vt_orig->init_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "init_pmc"), vt_orig->init_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "inspect"), vt_orig->inspect);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "inspect_str"), vt_orig->inspect_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "instantiate"), vt_orig->instantiate);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "invoke"), vt_orig->invoke);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "is_equal"), vt_orig->is_equal);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "is_equal_num"), vt_orig->is_equal_num);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "is_equal_string"), vt_orig->is_equal_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "is_same"), vt_orig->is_same);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "isa"), vt_orig->isa);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "isa_pmc"), vt_orig->isa_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "logical_and"), vt_orig->logical_and);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "logical_not"), vt_orig->logical_not);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "logical_or"), vt_orig->logical_or);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "logical_xor"), vt_orig->logical_xor);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "mark"), vt_orig->mark);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "modulus"), vt_orig->modulus);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "modulus_float"), vt_orig->modulus_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "modulus_int"), vt_orig->modulus_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "morph"), vt_orig->morph);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "multiply"), vt_orig->multiply);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "multiply_float"), vt_orig->multiply_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "multiply_int"), vt_orig->multiply_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "name"), vt_orig->name);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "neg"), vt_orig->neg);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_float"), vt_orig->pop_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_integer"), vt_orig->pop_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_pmc"), vt_orig->pop_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_string"), vt_orig->pop_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "push_float"), vt_orig->push_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "push_integer"), vt_orig->push_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "push_pmc"), vt_orig->push_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "push_string"), vt_orig->push_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "remove_attribute"), vt_orig->remove_attribute);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "remove_method"), vt_orig->remove_method);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "remove_parent"), vt_orig->remove_parent);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "remove_role"), vt_orig->remove_role);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "remove_vtable_override"), vt_orig->remove_vtable_override);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "repeat"), vt_orig->repeat);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "repeat_int"), vt_orig->repeat_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_attr_keyed"), vt_orig->set_attr_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_attr_str"), vt_orig->set_attr_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_bool"), vt_orig->set_bool);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_integer_keyed"), vt_orig->set_integer_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_integer_keyed_int"), vt_orig->set_integer_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_integer_keyed_str"), vt_orig->set_integer_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_integer_native"), vt_orig->set_integer_native);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_number_keyed"), vt_orig->set_number_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_number_keyed_int"), vt_orig->set_number_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_number_keyed_str"), vt_orig->set_number_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_number_native"), vt_orig->set_number_native);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pmc"), vt_orig->set_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pmc_keyed"), vt_orig->set_pmc_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pmc_keyed_int"), vt_orig->set_pmc_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pmc_keyed_str"), vt_orig->set_pmc_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pointer"), vt_orig->set_pointer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pointer_keyed"), vt_orig->set_pointer_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pointer_keyed_int"), vt_orig->set_pointer_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_pointer_keyed_str"), vt_orig->set_pointer_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_string_keyed"), vt_orig->set_string_keyed);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_string_keyed_int"), vt_orig->set_string_keyed_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_string_keyed_str"), vt_orig->set_string_keyed_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "set_string_native"), vt_orig->set_string_native);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "setprop"), vt_orig->setprop);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "share"), vt_orig->share);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "share_ro"), vt_orig->share_ro);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_float"), vt_orig->shift_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_integer"), vt_orig->shift_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_pmc"), vt_orig->shift_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_string"), vt_orig->shift_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "splice"), vt_orig->splice);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "substr"), vt_orig->substr);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "substr_str"), vt_orig->substr_str);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "subtract"), vt_orig->subtract);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "subtract_float"), vt_orig->subtract_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "subtract_int"), vt_orig->subtract_int);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "thaw"), vt_orig->thaw);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "thawfinish"), vt_orig->thawfinish);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "type"), vt_orig->type);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unshift_float"), vt_orig->unshift_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unshift_integer"), vt_orig->unshift_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unshift_pmc"), vt_orig->unshift_pmc);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unshift_string"), vt_orig->unshift_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "visit"), vt_orig->visit);
+ /* END vtable mapping name original */
+}
+
+/* BEGIN vtable stubs */
+static
+PMC* stub_absolute(PARROT_INTERP, PMC *pmc, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::absolute"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->absolute(interp, pmc, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_add(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::add"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->add(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_add_attribute(PARROT_INTERP, PMC *pmc, STRING* name, PMC* type) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, name, type);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::add_attribute"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->add_attribute(interp, pmc, name, type);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_add_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::add_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->add_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_add_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::add_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->add_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_add_method(PARROT_INTERP, PMC *pmc, STRING* method_name, PMC* sub_pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, method_name, sub_pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::add_method"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->add_method(interp, pmc, method_name, sub_pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_add_parent(PARROT_INTERP, PMC *pmc, PMC* parent) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, parent);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::add_parent"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->add_parent(interp, pmc, parent);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_add_role(PARROT_INTERP, PMC *pmc, PMC* role) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, role);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::add_role"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->add_role(interp, pmc, role);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_add_vtable_override(PARROT_INTERP, PMC *pmc, STRING* vtable_name, PMC* sub_pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, vtable_name, sub_pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::add_vtable_override"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->add_vtable_override(interp, pmc, vtable_name, sub_pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_assign_pmc(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::assign_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->assign_pmc(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_assign_string_native(PARROT_INTERP, PMC *pmc, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::assign_string_native"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->assign_string_native(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+INTVAL stub_can(PARROT_INTERP, PMC *pmc, STRING* method) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, method);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::can"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->can(interp, pmc, method);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_clone(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::clone"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->clone(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_clone_pmc(PARROT_INTERP, PMC *pmc, PMC* args) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, args);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::clone_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->clone_pmc(interp, pmc, args);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_cmp(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::cmp"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->cmp(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_cmp_num(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::cmp_num"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->cmp_num(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_cmp_pmc(PARROT_INTERP, PMC *pmc, PMC* value) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::cmp_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->cmp_pmc(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_cmp_string(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::cmp_string"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->cmp_string(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_concatenate(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::concatenate"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->concatenate(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_concatenate_str(PARROT_INTERP, PMC *pmc, STRING* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::concatenate_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->concatenate_str(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_decrement(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::decrement"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->decrement(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+INTVAL stub_defined(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::defined"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->defined(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_defined_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::defined_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->defined_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_defined_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::defined_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->defined_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_defined_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::defined_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->defined_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_delete_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::delete::delete_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->delete_keyed(interp, pmc, key);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_delete_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::delete::delete_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->delete_keyed_int(interp, pmc, key);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_delete_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::delete::delete_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->delete_keyed_str(interp, pmc, key);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_delprop(PARROT_INTERP, PMC *pmc, STRING* key) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::delprop"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->delprop(interp, pmc, key);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_destroy(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::destroy"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->destroy(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_divide(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::divide"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->divide(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::divide_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->divide_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::divide_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->divide_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_does(PARROT_INTERP, PMC *pmc, STRING* role) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, role);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::does"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->does(interp, pmc, role);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_does_pmc(PARROT_INTERP, PMC *pmc, PMC* role) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, role);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::does_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->does_pmc(interp, pmc, role);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_elements(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetchsize::elements"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->elements(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_exists_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::exists::exists_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->exists_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_exists_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::exists::exists_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->exists_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_exists_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::exists::exists_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->exists_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_find_method(PARROT_INTERP, PMC *pmc, STRING* method_name) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, method_name);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::find_method"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->find_method(interp, pmc, method_name);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_floor_divide(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::floor_divide"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->floor_divide(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_floor_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::floor_divide_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->floor_divide_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_floor_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::floor_divide_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->floor_divide_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_freeze(PARROT_INTERP, PMC *pmc, PMC* info) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, info);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::freeze"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->freeze(interp, pmc, info);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_get_attr_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* idx) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPS", pmc, key, idx);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::get_attr_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_attr_keyed(interp, pmc, key, idx);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_attr_str(PARROT_INTERP, PMC *pmc, STRING* idx) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, idx);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::get_attr_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_attr_str(interp, pmc, idx);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_get_bool(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_bool"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_bool(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_class(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::get_class"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_class(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_get_integer(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_integer"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_integer(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_integer_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_integer_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_integer_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_iter(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::get_iter"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_iter(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_namespace(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::get_namespace"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_namespace(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number(PARROT_INTERP, PMC *pmc) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_number"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_number(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_number_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_number_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_number_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_number_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_number_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_number_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_pmc(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pmc(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pmc_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pmc_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pmc_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void* stub_get_pointer(PARROT_INTERP, PMC *pmc) {
+ void* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pointer"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pointer(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
}
+static
+void* stub_get_pointer_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ void* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pointer_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ void* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pointer_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ void* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_pointer_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_get_repr(PARROT_INTERP, PMC *pmc) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_repr"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_repr(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_get_string(PARROT_INTERP, PMC *pmc) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_string"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_string(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_get_string_keyed(PARROT_INTERP, PMC *pmc, PMC* key) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_string_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_string_keyed(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_string_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_string_keyed_int(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::fetch::get_string_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->get_string_keyed_str(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_getprop(PARROT_INTERP, PMC *pmc, STRING* key) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, key);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::getprop"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->getprop(interp, pmc, key);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_getprops(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::getprops"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->getprops(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_hashvalue(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::hashvalue"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->hashvalue(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_i_absolute(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_absolute"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_absolute(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_add(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_add"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_add(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_add_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_add_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_add_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_add_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_add_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_add_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_concatenate(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::i_concatenate"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_concatenate(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_concatenate_str(PARROT_INTERP, PMC *pmc, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::i_concatenate_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_concatenate_str(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_divide(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_divide"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_divide(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_divide_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_divide_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_divide_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_divide_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_floor_divide(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_floor_divide"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_floor_divide(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_floor_divide_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_floor_divide_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_floor_divide_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_floor_divide_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_floor_divide_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_floor_divide_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_logical_not(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::i_logical_not"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_logical_not(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_modulus(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_modulus"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_modulus(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_modulus_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_modulus_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_modulus_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_modulus_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_modulus_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_modulus_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_multiply(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_multiply"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_multiply(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_multiply_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_multiply_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_multiply_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_multiply_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_multiply_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_multiply_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_neg(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_neg"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_neg(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_repeat(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::i_repeat"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_repeat(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_repeat_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::i_repeat_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_repeat_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_subtract(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_subtract"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_subtract(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_subtract_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_subtract_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_subtract_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_i_subtract_int(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::i_subtract_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->i_subtract_int(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_increment(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::increment"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->increment(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_init(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::init"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->init(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_init_int(PARROT_INTERP, PMC *pmc, INTVAL initializer) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, initializer);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::init_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->init_int(interp, pmc, initializer);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_init_pmc(PARROT_INTERP, PMC *pmc, PMC* initializer) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, initializer);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::init_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->init_pmc(interp, pmc, initializer);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_inspect(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::inspect"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->inspect(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_inspect_str(PARROT_INTERP, PMC *pmc, STRING* what) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, what);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::inspect_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->inspect_str(interp, pmc, what);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_instantiate(PARROT_INTERP, PMC *pmc, PMC* sig) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, sig);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::instantiate"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->instantiate(interp, pmc, sig);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+opcode_t* stub_invoke(PARROT_INTERP, PMC *pmc, void* next) {
+ opcode_t* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PV", pmc, next);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::invoke"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->invoke(interp, pmc, next);
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_is_equal(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::is_equal"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->is_equal(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_is_equal_num(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::is_equal_num"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->is_equal_num(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_is_equal_string(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::is_equal_string"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->is_equal_string(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_is_same(PARROT_INTERP, PMC *pmc, PMC* value) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::is_same"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->is_same(interp, pmc, value);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_isa(PARROT_INTERP, PMC *pmc, STRING* _class) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, _class);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::isa"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->isa(interp, pmc, _class);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_isa_pmc(PARROT_INTERP, PMC *pmc, PMC* _class) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, _class);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::isa_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->isa_pmc(interp, pmc, _class);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_logical_and(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::logical_and"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->logical_and(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_logical_not(PARROT_INTERP, PMC *pmc, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::logical_not"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->logical_not(interp, pmc, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_logical_or(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::logical_or"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->logical_or(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_logical_xor(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::cmp::logical_xor"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->logical_xor(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_mark(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::mark"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->mark(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_modulus(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::modulus"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->modulus(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_modulus_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::modulus_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->modulus_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_modulus_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::modulus_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->modulus_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_morph(PARROT_INTERP, PMC *pmc, PMC* type) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, type);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::morph"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->morph(interp, pmc, type);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_multiply(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::multiply"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->multiply(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_multiply_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::multiply_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->multiply_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_multiply_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::multiply_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->multiply_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_name(PARROT_INTERP, PMC *pmc) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::name"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->name(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_neg(PARROT_INTERP, PMC *pmc, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::neg"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->neg(interp, pmc, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_pop_float(PARROT_INTERP, PMC *pmc) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::pop::pop_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->pop_float(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_pop_integer(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::pop::pop_integer"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->pop_integer(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_pop_pmc(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::pop::pop_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->pop_pmc(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_pop_string(PARROT_INTERP, PMC *pmc) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::pop::pop_string"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->pop_string(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_push_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::push::push_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->push_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_push_integer(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::push::push_integer"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->push_integer(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_push_pmc(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::push::push_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->push_pmc(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_push_string(PARROT_INTERP, PMC *pmc, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::push::push_string"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->push_string(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_remove_attribute(PARROT_INTERP, PMC *pmc, STRING* name) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, name);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::remove_attribute"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->remove_attribute(interp, pmc, name);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_remove_method(PARROT_INTERP, PMC *pmc, STRING* method_name) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, method_name);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::remove_method"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->remove_method(interp, pmc, method_name);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_remove_parent(PARROT_INTERP, PMC *pmc, PMC* parent) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, parent);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::remove_parent"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->remove_parent(interp, pmc, parent);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_remove_role(PARROT_INTERP, PMC *pmc, PMC* role) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, role);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::remove_role"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->remove_role(interp, pmc, role);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_remove_vtable_override(PARROT_INTERP, PMC *pmc, STRING* vtable_name) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, vtable_name);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::remove_vtable_override"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->remove_vtable_override(interp, pmc, vtable_name);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_repeat(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::repeat"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->repeat(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_repeat_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::repeat_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->repeat_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_set_attr_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* idx, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPSP", pmc, key, idx, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::set_attr_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_attr_keyed(interp, pmc, key, idx, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_attr_str(PARROT_INTERP, PMC *pmc, STRING* idx, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, idx, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::set_attr_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_attr_str(interp, pmc, idx, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_bool(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_bool"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_bool(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_integer_keyed(PARROT_INTERP, PMC *pmc, PMC* key, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPI", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_integer_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_integer_keyed(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_integer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PII", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_integer_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_integer_keyed_int(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_integer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSI", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_integer_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_integer_keyed_str(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_integer_native(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_integer_native"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_integer_native(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_number_keyed(PARROT_INTERP, PMC *pmc, PMC* key, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPF", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_number_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_number_keyed(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_number_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIF", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_number_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_number_keyed_int(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_number_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSF", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_number_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_number_keyed_str(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_number_native(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_number_native"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_number_native(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pmc(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pmc(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pmc_keyed(PARROT_INTERP, PMC *pmc, PMC* key, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pmc_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pmc_keyed(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pmc_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pmc_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pmc_keyed_int(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pmc_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pmc_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pmc_keyed_str(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pointer(PARROT_INTERP, PMC *pmc, void* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PV", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pointer"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pointer(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pointer_keyed(PARROT_INTERP, PMC *pmc, PMC* key, void* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPV", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pointer_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pointer_keyed(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pointer_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, void* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIV", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pointer_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pointer_keyed_int(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_pointer_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, void* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSV", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_pointer_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_pointer_keyed_str(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_string_keyed(PARROT_INTERP, PMC *pmc, PMC* key, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPS", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_string_keyed"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_string_keyed(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_string_keyed_int(PARROT_INTERP, PMC *pmc, INTVAL key, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIS", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_string_keyed_int"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_string_keyed_int(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_string_keyed_str(PARROT_INTERP, PMC *pmc, STRING* key, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSS", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_string_keyed_str"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_string_keyed_str(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_set_string_native(PARROT_INTERP, PMC *pmc, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::store::set_string_native"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->set_string_native(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_setprop(PARROT_INTERP, PMC *pmc, STRING* key, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PSP", pmc, key, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::setprop"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->setprop(interp, pmc, key, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_share(PARROT_INTERP, PMC *pmc) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::share"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->share(interp, pmc);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+PMC* stub_share_ro(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::share_ro"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->share_ro(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+FLOATVAL stub_shift_float(PARROT_INTERP, PMC *pmc) {
+ FLOATVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::shift::shift_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->shift_float(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "F", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+INTVAL stub_shift_integer(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::shift::shift_integer"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->shift_integer(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_shift_pmc(PARROT_INTERP, PMC *pmc) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::shift::shift_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->shift_pmc(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+STRING* stub_shift_string(PARROT_INTERP, PMC *pmc) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::shift::shift_string"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->shift_string(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_splice(PARROT_INTERP, PMC *pmc, PMC* value, INTVAL offset, INTVAL count) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPII", pmc, value, offset, count);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::splice::splice"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->splice(interp, pmc, value, offset, count);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_substr(PARROT_INTERP, PMC *pmc, INTVAL offset, INTVAL length, PMC* dest) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIIP", pmc, offset, length, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::substr"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->substr(interp, pmc, offset, length, dest);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+STRING* stub_substr_str(PARROT_INTERP, PMC *pmc, INTVAL offset, INTVAL length) {
+ STRING* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PII", pmc, offset, length);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::string::substr_str"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->substr_str(interp, pmc, offset, length);
+ ret_pack = instrument_pack_params(supervisor, "S", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_subtract(PARROT_INTERP, PMC *pmc, PMC* value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PPP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::subtract"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->subtract(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_subtract_float(PARROT_INTERP, PMC *pmc, FLOATVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PFP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::subtract_float"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->subtract_float(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+PMC* stub_subtract_int(PARROT_INTERP, PMC *pmc, INTVAL value, PMC* dest) {
+ PMC* ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PIP", pmc, value, dest);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::math::subtract_int"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->subtract_int(interp, pmc, value, dest);
+ ret_pack = instrument_pack_params(supervisor, "P", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_thaw(PARROT_INTERP, PMC *pmc, PMC* info) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, info);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::thaw"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->thaw(interp, pmc, info);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_thawfinish(PARROT_INTERP, PMC *pmc, PMC* info) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, info);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::thawfinish"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->thawfinish(interp, pmc, info);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+INTVAL stub_type(PARROT_INTERP, PMC *pmc) {
+ INTVAL ret; PMC *ret_pack;
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "P", pmc);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::type"));
+ VTABLE_STUB_CALL_PRE;
+ ret = ((_vtable *)orig_vtable)->type(interp, pmc);
+ ret_pack = instrument_pack_params(supervisor, "I", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_STUB_CALL_POST;
+ return ret;
+}
+
+static
+void stub_unshift_float(PARROT_INTERP, PMC *pmc, FLOATVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PF", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::unshift::unshift_float"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->unshift_float(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_unshift_integer(PARROT_INTERP, PMC *pmc, INTVAL value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PI", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::unshift::unshift_integer"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->unshift_integer(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_unshift_pmc(PARROT_INTERP, PMC *pmc, PMC* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::unshift::unshift_pmc"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->unshift_pmc(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_unshift_string(PARROT_INTERP, PMC *pmc, STRING* value) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PS", pmc, value);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::unshift::unshift_string"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->unshift_string(interp, pmc, value);
+ VTABLE_STUB_CALL_POST;
+}
+
+static
+void stub_visit(PARROT_INTERP, PMC *pmc, PMC* info) {
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
+ params = instrument_pack_params(supervisor, "PP", pmc, info);
+ VTABLE_push_string(supervisor, event_array,
+ CONST_STRING(supervisor, "vtable::main::visit"));
+ VTABLE_STUB_CALL_PRE;
+ ((_vtable *)orig_vtable)->visit(interp, pmc, info);
+ VTABLE_STUB_CALL_POST;
+}
+
+/* END vtable stubs */
+
+/* END OF GENERATED CODE */
+
/*
=back
Modified: branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Sun Aug 8 16:36:50 2010 (r48347)
+++ branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Sun Aug 8 16:38:07 2010 (r48348)
@@ -75,6 +75,28 @@
} InstrumentGC_Subsystem;
/* END OF GENERATED CODE */
+/* Macros for generated stubs */
+#define GC_STUB_VARS \
+ GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original; \
+ Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor; \
+ PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc; \
+ PMC *instrument, *recall, *event_data, *temp, *params, *event_array; \
+ STRING *raise_event, *event; \
+ event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
+
+#define GC_STUB_CALL_PRE \
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, \
+ CONST_STRING(supervisor, "parameters"),params); \
+ raise_event = CONST_STRING(supervisor, "raise_event"); \
+ GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument); \
+ Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, \
+ "SP->P", event, event_data, &recall);
+
+#define GC_STUB_CALL_POST \
+ Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, \
+ "SPP->P", event, event_data, recall, &recall); \
+ probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+
/* Prototypes for helper functions. */
void setup_gc_common_hashes(PARROT_INTERP);
void destroy_gc_common_hashes(PARROT_INTERP);
@@ -740,716 +762,335 @@
/* BEGIN gc stubs */
void stub_finalize_gc_system(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::finalize_gc_system");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::finalize_gc_system");
+ GC_STUB_CALL_PRE;
(gc_orig->finalize_gc_system(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_destroy_child_interp(Interp* interp, Interp* child_interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VV", interp, child_interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::destroy_child_interp");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, child_interp);
+ event = CONST_STRING(supervisor, "GC::administration::destroy_child_interp");
+ GC_STUB_CALL_PRE;
(gc_orig->destroy_child_interp(interp, child_interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_do_gc_mark(Parrot_Interp interp, UINTVAL flags) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VV", interp, flags);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::do_gc_mark");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, flags);
+ event = CONST_STRING(supervisor, "GC::administration::do_gc_mark");
+ GC_STUB_CALL_PRE;
(gc_orig->do_gc_mark(interp, flags));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_compact_string_pool(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::compact_string_pool");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::compact_string_pool");
+ GC_STUB_CALL_PRE;
(gc_orig->compact_string_pool(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_mark_special(Parrot_Interp interp, PMC* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::mark_special");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::administration::mark_special");
+ GC_STUB_CALL_PRE;
(gc_orig->mark_special(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_pmc_needs_early_collection(Parrot_Interp interp, PMC* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::pmc_needs_early_collection");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::administration::pmc_needs_early_collection");
+ GC_STUB_CALL_PRE;
(gc_orig->pmc_needs_early_collection(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_init_pool(Parrot_Interp interp, struct Fixed_Size_Pool* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VV", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::init_pool");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::administration::init_pool");
+ GC_STUB_CALL_PRE;
(gc_orig->init_pool(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
PMC* stub_allocate_pmc_header(Parrot_Interp interp, UINTVAL flags) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- PMC* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, flags);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ PMC* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, flags);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_pmc_header");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
sizeof (PMC));
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_pmc_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_pmc_header(interp, flags));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_pmc_header(Parrot_Interp interp, PMC* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_pmc_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::free::free_pmc_header");
+ GC_STUB_CALL_PRE;
(gc_orig->free_pmc_header(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
STRING* stub_allocate_string_header(Parrot_Interp interp, UINTVAL flags) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- STRING* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, flags);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ STRING* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, flags);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_string_header");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
sizeof (STRING));
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_string_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_string_header(interp, flags));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_string_header(Parrot_Interp interp, STRING* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VS", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_string_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VS", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::free::free_string_header");
+ GC_STUB_CALL_PRE;
(gc_orig->free_string_header(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
Buffer* stub_allocate_bufferlike_header(Parrot_Interp interp, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- Buffer* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ Buffer* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VI", interp, size);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_bufferlike_header");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
sizeof (Buffer));
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_bufferlike_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_bufferlike_header(interp, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_bufferlike_header(Parrot_Interp interp, Buffer* stub_var1, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VVV", interp, stub_var1, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_bufferlike_header");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VVI", interp, stub_var1, size);
+ event = CONST_STRING(supervisor, "GC::free::free_bufferlike_header");
+ GC_STUB_CALL_PRE;
(gc_orig->free_bufferlike_header(interp, stub_var1, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void* stub_allocate_pmc_attributes(Parrot_Interp interp, PMC* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_pmc_attributes");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
VTABLE_get_pmc_keyed_int(supervisor, params, 0)->vtable->attr_size);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_pmc_attributes");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_pmc_attributes(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_pmc_attributes(Parrot_Interp interp, PMC* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_pmc_attributes");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VP", interp, stub_var1);
+ event = CONST_STRING(supervisor, "GC::free::free_pmc_attributes");
+ GC_STUB_CALL_PRE;
(gc_orig->free_pmc_attributes(interp, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_allocate_string_storage(Parrot_Interp interp, STRING* str, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VSV", interp, str, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VSI", interp, str, size);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_string_storage");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
size);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_string_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
(gc_orig->allocate_string_storage(interp, str, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_reallocate_string_storage(Parrot_Interp interp, STRING* str, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VSV", interp, str, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VSI", interp, str, size);
+ event = CONST_STRING(supervisor, "GC::reallocate::reallocate_string_storage");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
size);
-
- event = CONST_STRING(supervisor, "GC::reallocate::reallocate_string_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
(gc_orig->reallocate_string_storage(interp, str, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_allocate_buffer_storage(Parrot_Interp interp, Buffer* buffer, size_t nsize) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VVV", interp, buffer, nsize);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VVI", interp, buffer, nsize);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_buffer_storage");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
nsize);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_buffer_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
(gc_orig->allocate_buffer_storage(interp, buffer, nsize));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_reallocate_buffer_storage(Parrot_Interp interp, Buffer* buffer, size_t newsize) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VVV", interp, buffer, newsize);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VVI", interp, buffer, newsize);
+ event = CONST_STRING(supervisor, "GC::reallocate::reallocate_buffer_storage");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
newsize);
-
- event = CONST_STRING(supervisor, "GC::reallocate::reallocate_buffer_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
(gc_orig->reallocate_buffer_storage(interp, buffer, newsize));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void* stub_allocate_fixed_size_storage(Parrot_Interp interp, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VI", interp, size);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_fixed_size_storage");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
size);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_fixed_size_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_fixed_size_storage(interp, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_fixed_size_storage(Parrot_Interp interp, size_t size, void* stub_var1) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VVV", interp, size, stub_var1);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_fixed_size_storage");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VIV", interp, size, stub_var1);
+ event = CONST_STRING(supervisor, "GC::free::free_fixed_size_storage");
+ GC_STUB_CALL_PRE;
(gc_orig->free_fixed_size_storage(interp, size, stub_var1));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void* stub_allocate_memory_chunk(Parrot_Interp interp, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VI", interp, size);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_memory_chunk");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
size);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_memory_chunk");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_memory_chunk(interp, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void* stub_reallocate_memory_chunk(Parrot_Interp interp, void* data, size_t newsize) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VVV", interp, data, newsize);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VVI", interp, data, newsize);
+ event = CONST_STRING(supervisor, "GC::reallocate::reallocate_memory_chunk");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
newsize);
-
- event = CONST_STRING(supervisor, "GC::reallocate::reallocate_memory_chunk");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->reallocate_memory_chunk(interp, data, newsize));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void* stub_allocate_memory_chunk_with_interior_pointers(Parrot_Interp interp, size_t size) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VV", interp, size);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VI", interp, size);
+ event = CONST_STRING(supervisor, "GC::allocate::allocate_memory_chunk_with_interior_pointers");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
size);
-
- event = CONST_STRING(supervisor, "GC::allocate::allocate_memory_chunk_with_interior_pointers");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->allocate_memory_chunk_with_interior_pointers(interp, size));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void* stub_reallocate_memory_chunk_with_interior_pointers(Parrot_Interp interp, void* data, size_t oldsize, size_t newsize) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
- void* ret;
- PMC *ret_pack;
-
- params = instrument_pack_params(supervisor, "VVVV", interp, data, oldsize, newsize);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
+ void* ret; PMC *ret_pack;
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VVII", interp, data, oldsize, newsize);
+ event = CONST_STRING(supervisor, "GC::reallocate::reallocate_memory_chunk_with_interior_pointers");
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
newsize);
-
- event = CONST_STRING(supervisor, "GC::reallocate::reallocate_memory_chunk_with_interior_pointers");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_CALL_PRE;
ret = (gc_orig->reallocate_memory_chunk_with_interior_pointers(interp, data, oldsize, newsize));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ ret_pack = instrument_pack_params(supervisor, "V", ret);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
+ GC_STUB_CALL_POST;
return ret;
}
void stub_free_memory_chunk(Parrot_Interp interp, void* data) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "VV", interp, data);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::free::free_memory_chunk");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "VV", interp, data);
+ event = CONST_STRING(supervisor, "GC::free::free_memory_chunk");
+ GC_STUB_CALL_PRE;
(gc_orig->free_memory_chunk(interp, data));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_block_mark(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::block_mark");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::block_mark");
+ GC_STUB_CALL_PRE;
(gc_orig->block_mark(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_unblock_mark(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::unblock_mark");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::unblock_mark");
+ GC_STUB_CALL_PRE;
(gc_orig->unblock_mark(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_block_sweep(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::block_sweep");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::block_sweep");
+ GC_STUB_CALL_PRE;
(gc_orig->block_sweep(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
void stub_unblock_sweep(Parrot_Interp interp) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;
-
- params = instrument_pack_params(supervisor, "V", interp);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-
- event = CONST_STRING(supervisor, "GC::administration::unblock_sweep");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "V", interp);
+ event = CONST_STRING(supervisor, "GC::administration::unblock_sweep");
+ GC_STUB_CALL_PRE;
(gc_orig->unblock_sweep(interp));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));
+ GC_STUB_CALL_POST;
}
/* END gc stubs */
Modified: branches/gsoc_instrument/tools/build/gen_gc_stubs.pl
==============================================================================
--- branches/gsoc_instrument/tools/build/gen_gc_stubs.pl Sun Aug 8 16:36:50 2010 (r48347)
+++ branches/gsoc_instrument/tools/build/gen_gc_stubs.pl Sun Aug 8 16:38:07 2010 (r48348)
@@ -40,7 +40,8 @@
'PMC*' => 'P',
'INTVAL' => 'I',
'FLOATVAL' => 'F',
- 'STRING*' => 'S'
+ 'STRING*' => 'S',
+ 'size_t' => 'I'
);
my(%groups, @entries, @prototypes, @stubs, %stub_memory_sizes);
@@ -211,15 +212,16 @@
# Prepare the return value.
my($ret_declaration, $ret_receive, $ret_return, $ret_pack) = ('', '', '', '');
if($ret !~ /^\s*void\s*$/) {
- $ret_declaration = "\n $ret ret;\n PMC *ret_pack;";
+ $ret_declaration = "\n $ret ret; PMC *ret_pack;";
$ret_receive = "ret = ";
$ret_return = "\n return ret;";
my $type = ($param_type{$ret} || 'V');
$ret_pack = "\n".<<PACK;
ret_pack = instrument_pack_params(supervisor, "$type", ret);
- VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "return"), ret_pack);
PACK
+ chomp $ret_pack;
}
# For allocations and reallocations, expose the size of the allocation.
@@ -227,26 +229,13 @@
my $event = 'GC::'.$group.'::'.$name;
return <<STUB;
-$ret stub_$name($args) {
- GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
- PMC *instrumentgc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
- PMC *instrument, *recall, *event_data, *temp, *params, *event_array;
- STRING *raise_event, *event;$ret_declaration
-
- params = instrument_pack_params(supervisor, "$param_format", $param_flat);
- event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "parameters"),params);
-$alloc
- event = CONST_STRING(supervisor, "$event");
- raise_event = CONST_STRING(supervisor, "raise_event");
- GETATTR_InstrumentGC_instrument(supervisor, instrumentgc, instrument);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SP->P", event, event_data, &recall);
- $ret_receive(gc_orig->$name($param_flat));
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event,
- "SPP->P", event, event_data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));$ret_return
+$ret stub_$name($args) {$ret_declaration
+ GC_STUB_VARS;
+ params = instrument_pack_params(supervisor, "$param_format", $param_flat);
+ event = CONST_STRING(supervisor, "$event");$alloc
+ GC_STUB_CALL_PRE;
+ $ret_receive(gc_orig->$name($param_flat));$ret_pack
+ GC_STUB_CALL_POST;$ret_return
}
STUB
@@ -375,7 +364,8 @@
'allocate_pmc_header' => 'sizeof (PMC)',
'allocate_string_header' => 'sizeof (STRING)',
'allocate_bufferlike_header' => 'sizeof (Buffer)',
- 'allocate_pmc_attributes' => 'VTABLE_get_pmc_keyed_int(supervisor, params, 0)->vtable->attr_size',
+ 'allocate_pmc_attributes' => 'VTABLE_get_pmc_keyed_int(supervisor, params, 0)'.
+ '->vtable->attr_size',
'allocate_string_storage' => 'size',
'allocate_buffer_storage' => 'nsize',
'allocate_fixed_size_storage' => 'size',
@@ -390,10 +380,11 @@
my $key;
for $key (keys %sources) {
my $source = $sources{$key};
- $ref->{$key} = <<SIZE;
+ $ref->{$key} = "\n".<<SIZE;
VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"),
$source);
SIZE
+ chomp $ref->{$key};
}
}
Modified: branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
==============================================================================
--- branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sun Aug 8 16:36:50 2010 (r48347)
+++ branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sun Aug 8 16:38:07 2010 (r48348)
@@ -33,7 +33,7 @@
'STRING*' => 'S'
);
-my $dynpmc_file = 'src/dynpmc/instrumentvtable.pmc';
+my $dynpmc_file = 'src/dynpmc/instrumentclass.pmc';
my $dynpmc_fh = IO::File->new($dynpmc_file, O_RDWR | O_CREAT);
die "Could not open $dynpmc_file!" if !$dynpmc_fh;
@@ -142,7 +142,7 @@
# Prepare the return value.
my($ret_declaration, $ret_receive, $ret_return, $ret_pack) = ('', '', '', '');
if($ret ne 'void') {
- $ret_declaration = "\n $ret ret;\n PMC *ret_pack;";
+ $ret_declaration = "\n $ret ret; PMC *ret_pack;";
$ret_receive = "ret = ";
$ret_return = "\n return ret;";
@@ -151,6 +151,7 @@
ret_pack = instrument_pack_params(supervisor, "$type", ret);
VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "return"), ret_pack);
PACK
+ chomp $ret_pack;
}
# Prepare the event string to be appended to the the event prefix.
@@ -159,33 +160,15 @@
# Return the generated stub.
return <<CODE;
static
-$ret stub_$name(PARROT_INTERP, PMC *pmc$args) {
- PMC *instrument, *instrumentvt, *params, *data, *event_array, *recall;
- Parrot_Interp supervisor;
- STRING *raise_event, *event;
- void *orig_vtable;$ret_declaration
-
- instrumentvt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
- GETATTR_InstrumentVtable_original_struct(interp, instrumentvt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instrumentvt, supervisor);
- GETATTR_InstrumentVtable_event_prefix(interp, instrumentvt, event_array);
-
+$ret stub_$name(PARROT_INTERP, PMC *pmc$args) {$ret_declaration
+ VTABLE_STUB_VARS;
+ VTABLE_STUB_SETUP;
params = instrument_pack_params(supervisor, "$param_format", $param_flat);
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
- VTABLE_set_pmc_keyed_str(supervisor, data, CONST_STRING(supervisor, "parameters"), params);
-
- event_array = VTABLE_clone(supervisor, event_array);
VTABLE_push_string(supervisor, event_array,
CONST_STRING(supervisor, "$event_entry"));
-
- raise_event = CONST_STRING(supervisor, "raise_event");
- event = Parrot_str_join(supervisor, CONST_STRING(supervisor, "::"), event_array);
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, "SP->P",
- event, data, &recall);
+ VTABLE_STUB_CALL_PRE;
$ret_receive((_vtable *)orig_vtable)->$name(interp, $param_flat);$ret_pack
- Parrot_pcc_invoke_method_from_c_args(supervisor, instrument, raise_event, "SPP->P",
- event, data, recall, &recall);
- probe_list_delete_list(supervisor, (probe_list_t *)VTABLE_get_pointer(supervisor, recall));$ret_return
+ VTABLE_STUB_CALL_POST;$ret_return
}
CODE
More information about the parrot-commits
mailing list