[svn:parrot] r48063 - in branches/gsoc_instrument: . src src/dynpmc tools/build
khairul at svn.parrot.org
khairul at svn.parrot.org
Sat Jul 10 05:58:16 UTC 2010
Author: khairul
Date: Sat Jul 10 05:58:14 2010
New Revision: 48063
URL: https://trac.parrot.org/parrot/changeset/48063
Log:
Added generator for vtables.
Added:
branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
Modified:
branches/gsoc_instrument/MANIFEST
branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
branches/gsoc_instrument/src/vtable.tbl
Modified: branches/gsoc_instrument/MANIFEST
==============================================================================
--- branches/gsoc_instrument/MANIFEST Fri Jul 9 13:29:20 2010 (r48062)
+++ branches/gsoc_instrument/MANIFEST Sat Jul 10 05:58:14 2010 (r48063)
@@ -2103,6 +2103,7 @@
tools/build/addopstags.pl []
tools/build/c2str.pl []
tools/build/fixup_gen_file.pl []
+tools/build/gen_vtable_stubs.pl []
tools/build/h2inc.pl []
tools/build/headerizer.pl []
tools/build/ops2c.pl [devel]
Modified: branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Fri Jul 9 13:29:20 2010 (r48062)
+++ branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Sat Jul 10 05:58:14 2010 (r48063)
@@ -23,195 +23,159 @@
#include "pmc_instrument.h"
/* Stub Prototypes */
-/* BEGIN: vtable_prototypes */
-static PMC* stub_vtable_absolute(PARROT_INTERP, PMC* pmc, PMC* dest);
-static PMC* stub_vtable_add(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static void stub_vtable_add_attribute(PARROT_INTERP, PMC* pmc, STRING* name, PMC* type);
-static PMC* stub_vtable_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_add_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static void stub_vtable_add_method(PARROT_INTERP, PMC* pmc, STRING* method_name, PMC* sub_pmc);
-static void stub_vtable_add_parent(PARROT_INTERP, PMC* pmc, PMC* parent);
-static void stub_vtable_add_role(PARROT_INTERP, PMC* pmc, PMC* role);
-static void stub_vtable_add_vtable_override(PARROT_INTERP, PMC* pmc,
- STRING* vtable_name, PMC* sub_pmc);
-static void stub_vtable_assign_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* value);
-static INTVAL stub_vtable_can(PARROT_INTERP, PMC* pmc, STRING* method);
-static PMC* stub_vtable_clone(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args);
-static INTVAL stub_vtable_cmp(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_cmp_num(PARROT_INTERP, PMC* pmc, PMC* value);
-static PMC* stub_vtable_cmp_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_cmp_string(PARROT_INTERP, PMC* pmc, PMC* value);
-static PMC* stub_vtable_concatenate(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value, PMC* dest);
-static void stub_vtable_decrement(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_defined(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_defined_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static INTVAL stub_vtable_defined_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static INTVAL stub_vtable_defined_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static void stub_vtable_delete_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static void stub_vtable_delete_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static void stub_vtable_delete_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static void stub_vtable_delprop(PARROT_INTERP, PMC* pmc, STRING* key);
-static void stub_vtable_destroy(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static INTVAL stub_vtable_does(PARROT_INTERP, PMC* pmc, STRING* role);
-static INTVAL stub_vtable_does_pmc(PARROT_INTERP, PMC* pmc, PMC* role);
-static INTVAL stub_vtable_elements(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_exists_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static INTVAL stub_vtable_exists_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static INTVAL stub_vtable_exists_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static PMC* stub_vtable_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name);
-static PMC* stub_vtable_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static void stub_vtable_freeze(PARROT_INTERP, PMC* pmc, PMC* info);
-static PMC* stub_vtable_get_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx);
-static PMC* stub_vtable_get_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx);
-static INTVAL stub_vtable_get_bool(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_get_class(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_get_integer(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static INTVAL stub_vtable_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static INTVAL stub_vtable_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static PMC* stub_vtable_get_iter(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_get_namespace(PARROT_INTERP, PMC* pmc);
-static FLOATVAL stub_vtable_get_number(PARROT_INTERP, PMC* pmc);
-static FLOATVAL stub_vtable_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static FLOATVAL stub_vtable_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static FLOATVAL stub_vtable_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static PMC* stub_vtable_get_pmc(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static PMC* stub_vtable_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static PMC* stub_vtable_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static void* stub_vtable_get_pointer(PARROT_INTERP, PMC* pmc);
-static void* stub_vtable_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static void* stub_vtable_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static void* stub_vtable_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static STRING* stub_vtable_get_repr(PARROT_INTERP, PMC* pmc);
-static STRING* stub_vtable_get_string(PARROT_INTERP, PMC* pmc);
-static STRING* stub_vtable_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
-static STRING* stub_vtable_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
-static STRING* stub_vtable_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
-static PMC* stub_vtable_getprop(PARROT_INTERP, PMC* pmc, STRING* key);
-static PMC* stub_vtable_getprops(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_hashvalue(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_i_absolute(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_i_add(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_add_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_concatenate(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value);
-static void stub_vtable_i_divide(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_logical_not(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_i_modulus(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_multiply(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_neg(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_i_repeat(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_i_subtract(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_i_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_i_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_increment(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_init(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer);
-static void stub_vtable_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer);
-static PMC* stub_vtable_inspect(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_inspect_str(PARROT_INTERP, PMC* pmc, STRING* what);
-static PMC* stub_vtable_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig);
-static opcode_t* stub_vtable_invoke(PARROT_INTERP, PMC* pmc, void* next);
-static INTVAL stub_vtable_is_equal(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_is_equal_num(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_is_equal_string(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_is_same(PARROT_INTERP, PMC* pmc, PMC* value);
-static INTVAL stub_vtable_isa(PARROT_INTERP, PMC* pmc, STRING* _class);
-static INTVAL stub_vtable_isa_pmc(PARROT_INTERP, PMC* pmc, PMC* _class);
-static PMC* stub_vtable_logical_and(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_logical_not(PARROT_INTERP, PMC* pmc, PMC* dest);
-static PMC* stub_vtable_logical_or(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_logical_xor(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static void stub_vtable_mark(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_modulus(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static void stub_vtable_morph(PARROT_INTERP, PMC* pmc, PMC* type);
-static PMC* stub_vtable_multiply(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static STRING* stub_vtable_name(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_neg(PARROT_INTERP, PMC* pmc, PMC* dest);
-static FLOATVAL stub_vtable_pop_float(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_pop_integer(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_pop_pmc(PARROT_INTERP, PMC* pmc);
-static STRING* stub_vtable_pop_string(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_push_string(PARROT_INTERP, PMC* pmc, STRING* value);
-static void stub_vtable_remove_attribute(PARROT_INTERP, PMC* pmc, STRING* name);
-static void stub_vtable_remove_method(PARROT_INTERP, PMC* pmc, STRING* method_name);
-static void stub_vtable_remove_parent(PARROT_INTERP, PMC* pmc, PMC* parent);
-static void stub_vtable_remove_role(PARROT_INTERP, PMC* pmc, PMC* role);
-static void stub_vtable_remove_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name);
-static PMC* stub_vtable_repeat(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static void stub_vtable_set_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx, PMC* value);
-static void stub_vtable_set_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx, PMC* value);
-static void stub_vtable_set_bool(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_set_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, INTVAL value);
-static void stub_vtable_set_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, INTVAL value);
-static void stub_vtable_set_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, INTVAL value);
-static void stub_vtable_set_integer_native(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_set_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key, FLOATVAL value);
-static void stub_vtable_set_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, FLOATVAL value);
-static void stub_vtable_set_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, FLOATVAL value);
-static void stub_vtable_set_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_set_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key, PMC* value);
-static void stub_vtable_set_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, PMC* value);
-static void stub_vtable_set_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value);
-static void stub_vtable_set_pointer(PARROT_INTERP, PMC* pmc, void* value);
-static void stub_vtable_set_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, void* value);
-static void stub_vtable_set_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, void* value);
-static void stub_vtable_set_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, void* value);
-static void stub_vtable_set_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* value);
-static void stub_vtable_set_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, STRING* value);
-static void stub_vtable_set_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, STRING* value);
-static void stub_vtable_set_string_native(PARROT_INTERP, PMC* pmc, STRING* value);
-static void stub_vtable_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value);
-static void stub_vtable_share(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_share_ro(PARROT_INTERP, PMC* pmc);
-static FLOATVAL stub_vtable_shift_float(PARROT_INTERP, PMC* pmc);
-static INTVAL stub_vtable_shift_integer(PARROT_INTERP, PMC* pmc);
-static PMC* stub_vtable_shift_pmc(PARROT_INTERP, PMC* pmc);
-static STRING* stub_vtable_shift_string(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_splice(PARROT_INTERP, PMC* pmc, PMC* value, INTVAL offset, INTVAL count);
-static void stub_vtable_substr(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length, PMC* dest);
-static STRING* stub_vtable_substr_str(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length);
-static PMC* stub_vtable_subtract(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
-static PMC* stub_vtable_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
-static PMC* stub_vtable_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
-static void stub_vtable_thaw(PARROT_INTERP, PMC* pmc, PMC* info);
-static void stub_vtable_thawfinish(PARROT_INTERP, PMC* pmc, PMC* info);
-static INTVAL stub_vtable_type(PARROT_INTERP, PMC* pmc);
-static void stub_vtable_unshift_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
-static void stub_vtable_unshift_integer(PARROT_INTERP, PMC* pmc, INTVAL value);
-static void stub_vtable_unshift_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
-static void stub_vtable_unshift_string(PARROT_INTERP, PMC* pmc, STRING* value);
-static void stub_vtable_visit(PARROT_INTERP, PMC* pmc, PMC* info);
-/* END vtable_prototypes */
+/* BEGIN vtable prototypes */
+static void stub_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer);
+static PMC* stub_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig);
+static void stub_morph(PARROT_INTERP, PMC* pmc, PMC* type);
+static PMC* stub_getprop(PARROT_INTERP, PMC* pmc, STRING* key);
+static void stub_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value);
+static void stub_delprop(PARROT_INTERP, PMC* pmc, STRING* key);
+static PMC* stub_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args);
+static PMC* stub_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name);
+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 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 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_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_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 void stub_set_integer_native(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_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL 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_string_native(PARROT_INTERP, PMC* pmc, STRING* value);
+static void stub_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* 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_bool(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_assign_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_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static void stub_push_string(PARROT_INTERP, PMC* pmc, STRING* value);
+static void stub_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_unshift_integer(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_unshift_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static void stub_unshift_string(PARROT_INTERP, PMC* pmc, STRING* value);
+static void stub_unshift_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_splice(PARROT_INTERP, PMC* pmc, PMC* value, INTVAL offset, INTVAL count);
+static PMC* stub_add(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_add_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_add(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_add_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_subtract(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_subtract(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_multiply(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_multiply(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_divide(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_modulus(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest);
+static PMC* stub_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest);
+static void stub_i_modulus(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+static void stub_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value);
+static PMC* stub_absolute(PARROT_INTERP, PMC* pmc, PMC* dest);
+static PMC* stub_neg(PARROT_INTERP, PMC* pmc, PMC* dest);
+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_cmp(PARROT_INTERP, PMC* pmc, PMC* value);
+static INTVAL stub_cmp_num(PARROT_INTERP, PMC* pmc, PMC* value);
+static INTVAL stub_cmp_string(PARROT_INTERP, PMC* pmc, PMC* value);
+static PMC* stub_cmp_pmc(PARROT_INTERP, PMC* pmc, PMC* value);
+static PMC* stub_logical_or(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_logical_and(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_logical_xor(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest);
+static PMC* stub_logical_not(PARROT_INTERP, PMC* pmc, PMC* dest);
+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_i_concatenate(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value);
+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_i_repeat(PARROT_INTERP, PMC* pmc, PMC* value);
+static void stub_i_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value);
+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 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 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 opcode_t* stub_invoke(PARROT_INTERP, PMC* pmc, void* next);
+static INTVAL stub_can(PARROT_INTERP, PMC* pmc, STRING* method);
+static INTVAL stub_does_pmc(PARROT_INTERP, PMC* pmc, PMC* role);
+static INTVAL stub_does(PARROT_INTERP, PMC* pmc, STRING* role);
+static INTVAL stub_isa_pmc(PARROT_INTERP, PMC* pmc, PMC* _class);
+static INTVAL stub_isa(PARROT_INTERP, PMC* pmc, STRING* _class);
+static PMC* stub_get_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx);
+static PMC* stub_get_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx);
+static void stub_set_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx, PMC* value);
+static void stub_set_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx, PMC* value);
+static void stub_add_parent(PARROT_INTERP, PMC* pmc, PMC* parent);
+static void stub_remove_parent(PARROT_INTERP, PMC* pmc, PMC* parent);
+static void stub_add_role(PARROT_INTERP, PMC* pmc, PMC* role);
+static void stub_remove_role(PARROT_INTERP, PMC* pmc, PMC* role);
+static void stub_add_attribute(PARROT_INTERP, PMC* pmc, STRING* name, PMC* type);
+static void stub_remove_attribute(PARROT_INTERP, PMC* pmc, STRING* name);
+static void stub_add_method(PARROT_INTERP, PMC* pmc, STRING* method_name, PMC* sub_pmc);
+static void stub_remove_method(PARROT_INTERP, PMC* pmc, STRING* method_name);
+static void stub_add_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name, PMC* sub_pmc);
+static void stub_remove_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name);
+static PMC* stub_inspect_str(PARROT_INTERP, PMC* pmc, STRING* what);
+static void stub_freeze(PARROT_INTERP, PMC* pmc, PMC* info);
+static void stub_thaw(PARROT_INTERP, PMC* pmc, PMC* info);
+static void stub_thawfinish(PARROT_INTERP, PMC* pmc, PMC* info);
+static void stub_visit(PARROT_INTERP, PMC* pmc, PMC* info);
+static void stub_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer);
+
+/* END vtable prototypes */
/* Helper Prototypes. */
void raise_vtable_event(PARROT_INTERP, Parrot_Interp supervised, PMC *pmc, PMC *data, STRING *type);
@@ -372,1128 +336,916 @@
_vtable *orig_vtable, _vtable *instr_vtable) {
/* BEGIN vtable mappings */
/* Build mappings for name -> original function.vtable entry */
- parrot_hash_put(interp, orig, CONST_STRING(interp, "absolute"),
- orig_vtable->absolute);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add"),
- orig_vtable->add);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_attribute"),
- orig_vtable->add_attribute);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_float"),
- orig_vtable->add_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_int"),
- orig_vtable->add_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_method"),
- orig_vtable->add_method);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_parent"),
- orig_vtable->add_parent);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_role"),
- orig_vtable->add_role);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "add_vtable_override"),
- orig_vtable->add_vtable_override);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "assign_pmc"),
- orig_vtable->assign_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "assign_string_native"),
- orig_vtable->assign_string_native);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "can"),
- orig_vtable->can);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "clone"),
- orig_vtable->clone);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "clone_pmc"),
- orig_vtable->clone_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp"),
- orig_vtable->cmp);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_num"),
- orig_vtable->cmp_num);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_pmc"),
- orig_vtable->cmp_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_string"),
- orig_vtable->cmp_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "concatenate"),
- orig_vtable->concatenate);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "concatenate_str"),
- orig_vtable->concatenate_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "decrement"),
- orig_vtable->decrement);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "defined"),
- orig_vtable->defined);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed"),
- orig_vtable->defined_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed_int"),
- orig_vtable->defined_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed_str"),
- orig_vtable->defined_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed"),
- orig_vtable->delete_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed_int"),
- orig_vtable->delete_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed_str"),
- orig_vtable->delete_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "delprop"),
- orig_vtable->delprop);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "destroy"),
- orig_vtable->destroy);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "divide"),
- orig_vtable->divide);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "divide_float"),
- orig_vtable->divide_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "divide_int"),
- orig_vtable->divide_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "does"),
- orig_vtable->does);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "does_pmc"),
- orig_vtable->does_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "elements"),
- orig_vtable->elements);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed"),
- orig_vtable->exists_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed_int"),
- orig_vtable->exists_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed_str"),
- orig_vtable->exists_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "find_method"),
- orig_vtable->find_method);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide"),
- orig_vtable->floor_divide);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide_float"),
- orig_vtable->floor_divide_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide_int"),
- orig_vtable->floor_divide_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "freeze"),
- orig_vtable->freeze);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_attr_keyed"),
- orig_vtable->get_attr_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_attr_str"),
- orig_vtable->get_attr_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_bool"),
- orig_vtable->get_bool);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_class"),
- orig_vtable->get_class);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer"),
- orig_vtable->get_integer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed"),
- orig_vtable->get_integer_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed_int"),
- orig_vtable->get_integer_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed_str"),
- orig_vtable->get_integer_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_iter"),
- orig_vtable->get_iter);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_namespace"),
- orig_vtable->get_namespace);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number"),
- orig_vtable->get_number);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed"),
- orig_vtable->get_number_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed_int"),
- orig_vtable->get_number_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed_str"),
- orig_vtable->get_number_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc"),
- orig_vtable->get_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed"),
- orig_vtable->get_pmc_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed_int"),
- orig_vtable->get_pmc_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed_str"),
- orig_vtable->get_pmc_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer"),
- orig_vtable->get_pointer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed"),
- orig_vtable->get_pointer_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed_int"),
- orig_vtable->get_pointer_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed_str"),
- orig_vtable->get_pointer_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_repr"),
- orig_vtable->get_repr);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string"),
- orig_vtable->get_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed"),
- orig_vtable->get_string_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed_int"),
- orig_vtable->get_string_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed_str"),
- orig_vtable->get_string_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "getprop"),
- orig_vtable->getprop);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "getprops"),
- orig_vtable->getprops);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "hashvalue"),
- orig_vtable->hashvalue);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_absolute"),
- orig_vtable->i_absolute);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add"),
- orig_vtable->i_add);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add_float"),
- orig_vtable->i_add_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add_int"),
- orig_vtable->i_add_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_concatenate"),
- orig_vtable->i_concatenate);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_concatenate_str"),
- orig_vtable->i_concatenate_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide"),
- orig_vtable->i_divide);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide_float"),
- orig_vtable->i_divide_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide_int"),
- orig_vtable->i_divide_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide"),
- orig_vtable->i_floor_divide);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide_float"),
- orig_vtable->i_floor_divide_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide_int"),
- orig_vtable->i_floor_divide_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_logical_not"),
- orig_vtable->i_logical_not);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus"),
- orig_vtable->i_modulus);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus_float"),
- orig_vtable->i_modulus_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus_int"),
- orig_vtable->i_modulus_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply"),
- orig_vtable->i_multiply);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply_float"),
- orig_vtable->i_multiply_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply_int"),
- orig_vtable->i_multiply_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_neg"),
- orig_vtable->i_neg);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_repeat"),
- orig_vtable->i_repeat);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_repeat_int"),
- orig_vtable->i_repeat_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract"),
- orig_vtable->i_subtract);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract_float"),
- orig_vtable->i_subtract_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract_int"),
- orig_vtable->i_subtract_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "increment"),
- orig_vtable->increment);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "init"),
- orig_vtable->init);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "init_int"),
- orig_vtable->init_int);
parrot_hash_put(interp, orig, CONST_STRING(interp, "init_pmc"),
- orig_vtable->init_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "inspect"),
- orig_vtable->inspect);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "inspect_str"),
- orig_vtable->inspect_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "instantiate"),
- orig_vtable->instantiate);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "invoke"),
- orig_vtable->invoke);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal"),
- orig_vtable->is_equal);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal_num"),
- orig_vtable->is_equal_num);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal_string"),
- orig_vtable->is_equal_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "is_same"),
- orig_vtable->is_same);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "isa"),
- orig_vtable->isa);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "isa_pmc"),
- orig_vtable->isa_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_and"),
- orig_vtable->logical_and);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_not"),
- orig_vtable->logical_not);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_or"),
- orig_vtable->logical_or);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_xor"),
- orig_vtable->logical_xor);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "mark"),
- orig_vtable->mark);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus"),
- orig_vtable->modulus);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus_float"),
- orig_vtable->modulus_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus_int"),
- orig_vtable->modulus_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "morph"),
- orig_vtable->morph);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply"),
- orig_vtable->multiply);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply_float"),
- orig_vtable->multiply_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply_int"),
- orig_vtable->multiply_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "name"),
- orig_vtable->name);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "neg"),
- orig_vtable->neg);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "pop_float"),
- orig_vtable->pop_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "pop_integer"),
- orig_vtable->pop_integer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "pop_pmc"),
- orig_vtable->pop_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "pop_string"),
- orig_vtable->pop_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "push_float"),
- orig_vtable->push_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "push_integer"),
- orig_vtable->push_integer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "push_pmc"),
- orig_vtable->push_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "push_string"),
- orig_vtable->push_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_attribute"),
- orig_vtable->remove_attribute);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_method"),
- orig_vtable->remove_method);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_parent"),
- orig_vtable->remove_parent);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_role"),
- orig_vtable->remove_role);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_vtable_override"),
- orig_vtable->remove_vtable_override);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "repeat"),
- orig_vtable->repeat);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "repeat_int"),
- orig_vtable->repeat_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_attr_keyed"),
- orig_vtable->set_attr_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_attr_str"),
- orig_vtable->set_attr_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_bool"),
- orig_vtable->set_bool);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed"),
- orig_vtable->set_integer_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed_int"),
- orig_vtable->set_integer_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed_str"),
- orig_vtable->set_integer_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_native"),
- orig_vtable->set_integer_native);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed"),
- orig_vtable->set_number_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed_int"),
- orig_vtable->set_number_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed_str"),
- orig_vtable->set_number_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_native"),
- orig_vtable->set_number_native);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc"),
- orig_vtable->set_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed"),
- orig_vtable->set_pmc_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed_int"),
- orig_vtable->set_pmc_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed_str"),
- orig_vtable->set_pmc_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer"),
- orig_vtable->set_pointer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed"),
- orig_vtable->set_pointer_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed_int"),
- orig_vtable->set_pointer_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed_str"),
- orig_vtable->set_pointer_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed"),
- orig_vtable->set_string_keyed);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed_int"),
- orig_vtable->set_string_keyed_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed_str"),
- orig_vtable->set_string_keyed_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_native"),
- orig_vtable->set_string_native);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "setprop"),
- orig_vtable->setprop);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "share"),
- orig_vtable->share);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "share_ro"),
- orig_vtable->share_ro);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "shift_float"),
- orig_vtable->shift_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "shift_integer"),
- orig_vtable->shift_integer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "shift_pmc"),
- orig_vtable->shift_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "shift_string"),
- orig_vtable->shift_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "splice"),
- orig_vtable->splice);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "substr"),
- orig_vtable->substr);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "substr_str"),
- orig_vtable->substr_str);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract"),
- orig_vtable->subtract);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract_float"),
- orig_vtable->subtract_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract_int"),
- orig_vtable->subtract_int);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "thaw"),
- orig_vtable->thaw);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "thawfinish"),
- orig_vtable->thawfinish);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "type"),
- orig_vtable->type);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_float"),
- orig_vtable->unshift_float);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_integer"),
- orig_vtable->unshift_integer);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_pmc"),
- orig_vtable->unshift_pmc);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_string"),
- orig_vtable->unshift_string);
- parrot_hash_put(interp, orig, CONST_STRING(interp, "visit"),
- orig_vtable->visit);
+ orig_vtable->init_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "instantiate"),
+ orig_vtable->instantiate);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "morph"),
+ orig_vtable->morph);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "getprop"),
+ orig_vtable->getprop);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "setprop"),
+ orig_vtable->setprop);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "delprop"),
+ orig_vtable->delprop);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "clone_pmc"),
+ orig_vtable->clone_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "find_method"),
+ orig_vtable->find_method);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed"),
+ orig_vtable->get_integer_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed_int"),
+ orig_vtable->get_integer_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_integer_keyed_str"),
+ orig_vtable->get_integer_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed"),
+ orig_vtable->get_number_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed_int"),
+ orig_vtable->get_number_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_number_keyed_str"),
+ orig_vtable->get_number_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed"),
+ orig_vtable->get_string_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed_int"),
+ orig_vtable->get_string_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_string_keyed_str"),
+ orig_vtable->get_string_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed"),
+ orig_vtable->get_pmc_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed_int"),
+ orig_vtable->get_pmc_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pmc_keyed_str"),
+ orig_vtable->get_pmc_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed"),
+ orig_vtable->get_pointer_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed_int"),
+ orig_vtable->get_pointer_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_pointer_keyed_str"),
+ orig_vtable->get_pointer_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_native"),
+ orig_vtable->set_integer_native);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed"),
+ orig_vtable->set_integer_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed_int"),
+ orig_vtable->set_integer_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_integer_keyed_str"),
+ orig_vtable->set_integer_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_native"),
+ orig_vtable->set_number_native);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed"),
+ orig_vtable->set_number_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed_int"),
+ orig_vtable->set_number_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_number_keyed_str"),
+ orig_vtable->set_number_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_native"),
+ orig_vtable->set_string_native);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "assign_string_native"),
+ orig_vtable->assign_string_native);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed"),
+ orig_vtable->set_string_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed_int"),
+ orig_vtable->set_string_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_string_keyed_str"),
+ orig_vtable->set_string_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_bool"),
+ orig_vtable->set_bool);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc"),
+ orig_vtable->set_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "assign_pmc"),
+ orig_vtable->assign_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed"),
+ orig_vtable->set_pmc_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed_int"),
+ orig_vtable->set_pmc_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pmc_keyed_str"),
+ orig_vtable->set_pmc_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer"),
+ orig_vtable->set_pointer);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed"),
+ orig_vtable->set_pointer_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed_int"),
+ orig_vtable->set_pointer_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_pointer_keyed_str"),
+ orig_vtable->set_pointer_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "push_integer"),
+ orig_vtable->push_integer);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "push_float"),
+ orig_vtable->push_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "push_string"),
+ orig_vtable->push_string);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "push_pmc"),
+ orig_vtable->push_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_integer"),
+ orig_vtable->unshift_integer);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_float"),
+ orig_vtable->unshift_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_string"),
+ orig_vtable->unshift_string);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "unshift_pmc"),
+ orig_vtable->unshift_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "splice"),
+ orig_vtable->splice);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add"),
+ orig_vtable->add);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_int"),
+ orig_vtable->add_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_float"),
+ orig_vtable->add_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add"),
+ orig_vtable->i_add);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add_int"),
+ orig_vtable->i_add_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_add_float"),
+ orig_vtable->i_add_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract"),
+ orig_vtable->subtract);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract_int"),
+ orig_vtable->subtract_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "subtract_float"),
+ orig_vtable->subtract_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract"),
+ orig_vtable->i_subtract);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract_int"),
+ orig_vtable->i_subtract_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_subtract_float"),
+ orig_vtable->i_subtract_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply"),
+ orig_vtable->multiply);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply_int"),
+ orig_vtable->multiply_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "multiply_float"),
+ orig_vtable->multiply_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply"),
+ orig_vtable->i_multiply);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply_int"),
+ orig_vtable->i_multiply_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_multiply_float"),
+ orig_vtable->i_multiply_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "divide"),
+ orig_vtable->divide);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "divide_int"),
+ orig_vtable->divide_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "divide_float"),
+ orig_vtable->divide_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide"),
+ orig_vtable->i_divide);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide_int"),
+ orig_vtable->i_divide_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_divide_float"),
+ orig_vtable->i_divide_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide"),
+ orig_vtable->floor_divide);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide_int"),
+ orig_vtable->floor_divide_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "floor_divide_float"),
+ orig_vtable->floor_divide_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide"),
+ orig_vtable->i_floor_divide);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide_int"),
+ orig_vtable->i_floor_divide_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_floor_divide_float"),
+ orig_vtable->i_floor_divide_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus"),
+ orig_vtable->modulus);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus_int"),
+ orig_vtable->modulus_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "modulus_float"),
+ orig_vtable->modulus_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus"),
+ orig_vtable->i_modulus);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus_int"),
+ orig_vtable->i_modulus_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_modulus_float"),
+ orig_vtable->i_modulus_float);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "absolute"),
+ orig_vtable->absolute);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "neg"),
+ orig_vtable->neg);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal"),
+ orig_vtable->is_equal);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal_num"),
+ orig_vtable->is_equal_num);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "is_equal_string"),
+ orig_vtable->is_equal_string);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "is_same"),
+ orig_vtable->is_same);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp"),
+ orig_vtable->cmp);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_num"),
+ orig_vtable->cmp_num);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_string"),
+ orig_vtable->cmp_string);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "cmp_pmc"),
+ orig_vtable->cmp_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_or"),
+ orig_vtable->logical_or);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_and"),
+ orig_vtable->logical_and);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_xor"),
+ orig_vtable->logical_xor);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "logical_not"),
+ orig_vtable->logical_not);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "concatenate"),
+ orig_vtable->concatenate);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "concatenate_str"),
+ orig_vtable->concatenate_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_concatenate"),
+ orig_vtable->i_concatenate);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_concatenate_str"),
+ orig_vtable->i_concatenate_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "repeat"),
+ orig_vtable->repeat);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "repeat_int"),
+ orig_vtable->repeat_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_repeat"),
+ orig_vtable->i_repeat);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "i_repeat_int"),
+ orig_vtable->i_repeat_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "substr"),
+ orig_vtable->substr);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "substr_str"),
+ orig_vtable->substr_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed"),
+ orig_vtable->exists_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed_int"),
+ orig_vtable->exists_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "exists_keyed_str"),
+ orig_vtable->exists_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed"),
+ orig_vtable->defined_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed_int"),
+ orig_vtable->defined_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "defined_keyed_str"),
+ orig_vtable->defined_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed"),
+ orig_vtable->delete_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed_int"),
+ orig_vtable->delete_keyed_int);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "delete_keyed_str"),
+ orig_vtable->delete_keyed_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "invoke"),
+ orig_vtable->invoke);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "can"),
+ orig_vtable->can);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "does_pmc"),
+ orig_vtable->does_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "does"),
+ orig_vtable->does);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "isa_pmc"),
+ orig_vtable->isa_pmc);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "isa"),
+ orig_vtable->isa);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_attr_str"),
+ orig_vtable->get_attr_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "get_attr_keyed"),
+ orig_vtable->get_attr_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_attr_str"),
+ orig_vtable->set_attr_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "set_attr_keyed"),
+ orig_vtable->set_attr_keyed);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_parent"),
+ orig_vtable->add_parent);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_parent"),
+ orig_vtable->remove_parent);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_role"),
+ orig_vtable->add_role);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_role"),
+ orig_vtable->remove_role);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_attribute"),
+ orig_vtable->add_attribute);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_attribute"),
+ orig_vtable->remove_attribute);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_method"),
+ orig_vtable->add_method);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_method"),
+ orig_vtable->remove_method);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "add_vtable_override"),
+ orig_vtable->add_vtable_override);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "remove_vtable_override"),
+ orig_vtable->remove_vtable_override);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "inspect_str"),
+ orig_vtable->inspect_str);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "freeze"),
+ orig_vtable->freeze);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "thaw"),
+ orig_vtable->thaw);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "thawfinish"),
+ orig_vtable->thawfinish);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "visit"),
+ orig_vtable->visit);
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "init_int"),
+ orig_vtable->init_int);
+
/* Build mappings for name -> instrumented function.vtable entry. */
- parrot_hash_put(interp, instr, CONST_STRING(interp, "absolute"),
- &(instr_vtable->absolute));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add"),
- &(instr_vtable->add));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_attribute"),
- &(instr_vtable->add_attribute));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_float"),
- &(instr_vtable->add_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_int"),
- &(instr_vtable->add_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_method"),
- &(instr_vtable->add_method));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_parent"),
- &(instr_vtable->add_parent));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_role"),
- &(instr_vtable->add_role));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "add_vtable_override"),
- &(instr_vtable->add_vtable_override));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "assign_pmc"),
- &(instr_vtable->assign_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "assign_string_native"),
- &(instr_vtable->assign_string_native));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "can"),
- &(instr_vtable->can));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "clone"),
- &(instr_vtable->clone));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "clone_pmc"),
- &(instr_vtable->clone_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp"),
- &(instr_vtable->cmp));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_num"),
- &(instr_vtable->cmp_num));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_pmc"),
- &(instr_vtable->cmp_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_string"),
- &(instr_vtable->cmp_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "concatenate"),
- &(instr_vtable->concatenate));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "concatenate_str"),
- &(instr_vtable->concatenate_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "decrement"),
- &(instr_vtable->decrement));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "defined"),
- &(instr_vtable->defined));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed"),
- &(instr_vtable->defined_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed_int"),
- &(instr_vtable->defined_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed_str"),
- &(instr_vtable->defined_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed"),
- &(instr_vtable->delete_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed_int"),
- &(instr_vtable->delete_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed_str"),
- &(instr_vtable->delete_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "delprop"),
- &(instr_vtable->delprop));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "destroy"),
- &(instr_vtable->destroy));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "divide"),
- &(instr_vtable->divide));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "divide_float"),
- &(instr_vtable->divide_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "divide_int"),
- &(instr_vtable->divide_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "does"),
- &(instr_vtable->does));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "does_pmc"),
- &(instr_vtable->does_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "elements"),
- &(instr_vtable->elements));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed"),
- &(instr_vtable->exists_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed_int"),
- &(instr_vtable->exists_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed_str"),
- &(instr_vtable->exists_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "find_method"),
- &(instr_vtable->find_method));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide"),
- &(instr_vtable->floor_divide));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide_float"),
- &(instr_vtable->floor_divide_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide_int"),
- &(instr_vtable->floor_divide_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "freeze"),
- &(instr_vtable->freeze));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_attr_keyed"),
- &(instr_vtable->get_attr_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_attr_str"),
- &(instr_vtable->get_attr_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_bool"),
- &(instr_vtable->get_bool));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_class"),
- &(instr_vtable->get_class));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer"),
- &(instr_vtable->get_integer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed"),
- &(instr_vtable->get_integer_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed_int"),
- &(instr_vtable->get_integer_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed_str"),
- &(instr_vtable->get_integer_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_iter"),
- &(instr_vtable->get_iter));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_namespace"),
- &(instr_vtable->get_namespace));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number"),
- &(instr_vtable->get_number));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed"),
- &(instr_vtable->get_number_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed_int"),
- &(instr_vtable->get_number_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed_str"),
- &(instr_vtable->get_number_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc"),
- &(instr_vtable->get_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed"),
- &(instr_vtable->get_pmc_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed_int"),
- &(instr_vtable->get_pmc_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed_str"),
- &(instr_vtable->get_pmc_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer"),
- &(instr_vtable->get_pointer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed"),
- &(instr_vtable->get_pointer_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed_int"),
- &(instr_vtable->get_pointer_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed_str"),
- &(instr_vtable->get_pointer_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_repr"),
- &(instr_vtable->get_repr));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string"),
- &(instr_vtable->get_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed"),
- &(instr_vtable->get_string_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed_int"),
- &(instr_vtable->get_string_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed_str"),
- &(instr_vtable->get_string_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "getprop"),
- &(instr_vtable->getprop));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "getprops"),
- &(instr_vtable->getprops));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "hashvalue"),
- &(instr_vtable->hashvalue));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_absolute"),
- &(instr_vtable->i_absolute));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add"),
- &(instr_vtable->i_add));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add_float"),
- &(instr_vtable->i_add_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add_int"),
- &(instr_vtable->i_add_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_concatenate"),
- &(instr_vtable->i_concatenate));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_concatenate_str"),
- &(instr_vtable->i_concatenate_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide"),
- &(instr_vtable->i_divide));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide_float"),
- &(instr_vtable->i_divide_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide_int"),
- &(instr_vtable->i_divide_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide"),
- &(instr_vtable->i_floor_divide));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide_float"),
- &(instr_vtable->i_floor_divide_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide_int"),
- &(instr_vtable->i_floor_divide_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_logical_not"),
- &(instr_vtable->i_logical_not));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus"),
- &(instr_vtable->i_modulus));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus_float"),
- &(instr_vtable->i_modulus_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus_int"),
- &(instr_vtable->i_modulus_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply"),
- &(instr_vtable->i_multiply));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply_float"),
- &(instr_vtable->i_multiply_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply_int"),
- &(instr_vtable->i_multiply_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_neg"),
- &(instr_vtable->i_neg));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_repeat"),
- &(instr_vtable->i_repeat));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_repeat_int"),
- &(instr_vtable->i_repeat_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract"),
- &(instr_vtable->i_subtract));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract_float"),
- &(instr_vtable->i_subtract_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract_int"),
- &(instr_vtable->i_subtract_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "increment"),
- &(instr_vtable->increment));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "init"),
- &(instr_vtable->init));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "init_int"),
- &(instr_vtable->init_int));
parrot_hash_put(interp, instr, CONST_STRING(interp, "init_pmc"),
- &(instr_vtable->init_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "inspect"),
- &(instr_vtable->inspect));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "inspect_str"),
- &(instr_vtable->inspect_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "instantiate"),
- &(instr_vtable->instantiate));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "invoke"),
- &(instr_vtable->invoke));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal"),
- &(instr_vtable->is_equal));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal_num"),
- &(instr_vtable->is_equal_num));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal_string"),
- &(instr_vtable->is_equal_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "is_same"),
- &(instr_vtable->is_same));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "isa"),
- &(instr_vtable->isa));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "isa_pmc"),
- &(instr_vtable->isa_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_and"),
- &(instr_vtable->logical_and));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_not"),
- &(instr_vtable->logical_not));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_or"),
- &(instr_vtable->logical_or));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_xor"),
- &(instr_vtable->logical_xor));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "mark"),
- &(instr_vtable->mark));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus"),
- &(instr_vtable->modulus));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus_float"),
- &(instr_vtable->modulus_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus_int"),
- &(instr_vtable->modulus_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "morph"),
- &(instr_vtable->morph));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply"),
- &(instr_vtable->multiply));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply_float"),
- &(instr_vtable->multiply_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply_int"),
- &(instr_vtable->multiply_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "name"),
- &(instr_vtable->name));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "neg"),
- &(instr_vtable->neg));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "pop_float"),
- &(instr_vtable->pop_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "pop_integer"),
- &(instr_vtable->pop_integer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "pop_pmc"),
- &(instr_vtable->pop_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "pop_string"),
- &(instr_vtable->pop_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "push_float"),
- &(instr_vtable->push_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "push_integer"),
- &(instr_vtable->push_integer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "push_pmc"),
- &(instr_vtable->push_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "push_string"),
- &(instr_vtable->push_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_attribute"),
- &(instr_vtable->remove_attribute));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_method"),
- &(instr_vtable->remove_method));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_parent"),
- &(instr_vtable->remove_parent));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_role"),
- &(instr_vtable->remove_role));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_vtable_override"),
- &(instr_vtable->remove_vtable_override));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "repeat"),
- &(instr_vtable->repeat));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "repeat_int"),
- &(instr_vtable->repeat_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_attr_keyed"),
- &(instr_vtable->set_attr_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_attr_str"),
- &(instr_vtable->set_attr_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_bool"),
- &(instr_vtable->set_bool));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed"),
- &(instr_vtable->set_integer_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed_int"),
- &(instr_vtable->set_integer_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed_str"),
- &(instr_vtable->set_integer_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_native"),
- &(instr_vtable->set_integer_native));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed"),
- &(instr_vtable->set_number_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed_int"),
- &(instr_vtable->set_number_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed_str"),
- &(instr_vtable->set_number_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_native"),
- &(instr_vtable->set_number_native));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc"),
- &(instr_vtable->set_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed"),
- &(instr_vtable->set_pmc_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed_int"),
- &(instr_vtable->set_pmc_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed_str"),
- &(instr_vtable->set_pmc_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer"),
- &(instr_vtable->set_pointer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed"),
- &(instr_vtable->set_pointer_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed_int"),
- &(instr_vtable->set_pointer_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed_str"),
- &(instr_vtable->set_pointer_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed"),
- &(instr_vtable->set_string_keyed));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed_int"),
- &(instr_vtable->set_string_keyed_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed_str"),
- &(instr_vtable->set_string_keyed_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_native"),
- &(instr_vtable->set_string_native));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "setprop"),
- &(instr_vtable->setprop));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "share"),
- &(instr_vtable->share));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "share_ro"),
- &(instr_vtable->share_ro));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "shift_float"),
- &(instr_vtable->shift_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "shift_integer"),
- &(instr_vtable->shift_integer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "shift_pmc"),
- &(instr_vtable->shift_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "shift_string"),
- &(instr_vtable->shift_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "splice"),
- &(instr_vtable->splice));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "substr"),
- &(instr_vtable->substr));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "substr_str"),
- &(instr_vtable->substr_str));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract"),
- &(instr_vtable->subtract));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract_float"),
- &(instr_vtable->subtract_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract_int"),
- &(instr_vtable->subtract_int));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "thaw"),
- &(instr_vtable->thaw));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "thawfinish"),
- &(instr_vtable->thawfinish));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "type"),
- &(instr_vtable->type));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_float"),
- &(instr_vtable->unshift_float));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_integer"),
- &(instr_vtable->unshift_integer));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_pmc"),
- &(instr_vtable->unshift_pmc));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_string"),
- &(instr_vtable->unshift_string));
- parrot_hash_put(interp, instr, CONST_STRING(interp, "visit"),
- &(instr_vtable->visit));
+ &(instr_vtable->init_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "instantiate"),
+ &(instr_vtable->instantiate));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "morph"),
+ &(instr_vtable->morph));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "getprop"),
+ &(instr_vtable->getprop));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "setprop"),
+ &(instr_vtable->setprop));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "delprop"),
+ &(instr_vtable->delprop));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "clone_pmc"),
+ &(instr_vtable->clone_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "find_method"),
+ &(instr_vtable->find_method));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed"),
+ &(instr_vtable->get_integer_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed_int"),
+ &(instr_vtable->get_integer_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_integer_keyed_str"),
+ &(instr_vtable->get_integer_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed"),
+ &(instr_vtable->get_number_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed_int"),
+ &(instr_vtable->get_number_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_number_keyed_str"),
+ &(instr_vtable->get_number_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed"),
+ &(instr_vtable->get_string_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed_int"),
+ &(instr_vtable->get_string_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_string_keyed_str"),
+ &(instr_vtable->get_string_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed"),
+ &(instr_vtable->get_pmc_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed_int"),
+ &(instr_vtable->get_pmc_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pmc_keyed_str"),
+ &(instr_vtable->get_pmc_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed"),
+ &(instr_vtable->get_pointer_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed_int"),
+ &(instr_vtable->get_pointer_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_pointer_keyed_str"),
+ &(instr_vtable->get_pointer_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_native"),
+ &(instr_vtable->set_integer_native));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed"),
+ &(instr_vtable->set_integer_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed_int"),
+ &(instr_vtable->set_integer_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_integer_keyed_str"),
+ &(instr_vtable->set_integer_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_native"),
+ &(instr_vtable->set_number_native));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed"),
+ &(instr_vtable->set_number_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed_int"),
+ &(instr_vtable->set_number_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_number_keyed_str"),
+ &(instr_vtable->set_number_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_native"),
+ &(instr_vtable->set_string_native));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "assign_string_native"),
+ &(instr_vtable->assign_string_native));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed"),
+ &(instr_vtable->set_string_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed_int"),
+ &(instr_vtable->set_string_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_string_keyed_str"),
+ &(instr_vtable->set_string_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_bool"),
+ &(instr_vtable->set_bool));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc"),
+ &(instr_vtable->set_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "assign_pmc"),
+ &(instr_vtable->assign_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed"),
+ &(instr_vtable->set_pmc_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed_int"),
+ &(instr_vtable->set_pmc_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pmc_keyed_str"),
+ &(instr_vtable->set_pmc_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer"),
+ &(instr_vtable->set_pointer));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed"),
+ &(instr_vtable->set_pointer_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed_int"),
+ &(instr_vtable->set_pointer_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_pointer_keyed_str"),
+ &(instr_vtable->set_pointer_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "push_integer"),
+ &(instr_vtable->push_integer));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "push_float"),
+ &(instr_vtable->push_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "push_string"),
+ &(instr_vtable->push_string));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "push_pmc"),
+ &(instr_vtable->push_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_integer"),
+ &(instr_vtable->unshift_integer));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_float"),
+ &(instr_vtable->unshift_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_string"),
+ &(instr_vtable->unshift_string));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "unshift_pmc"),
+ &(instr_vtable->unshift_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "splice"),
+ &(instr_vtable->splice));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add"),
+ &(instr_vtable->add));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_int"),
+ &(instr_vtable->add_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_float"),
+ &(instr_vtable->add_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add"),
+ &(instr_vtable->i_add));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add_int"),
+ &(instr_vtable->i_add_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_add_float"),
+ &(instr_vtable->i_add_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract"),
+ &(instr_vtable->subtract));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract_int"),
+ &(instr_vtable->subtract_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "subtract_float"),
+ &(instr_vtable->subtract_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract"),
+ &(instr_vtable->i_subtract));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract_int"),
+ &(instr_vtable->i_subtract_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_subtract_float"),
+ &(instr_vtable->i_subtract_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply"),
+ &(instr_vtable->multiply));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply_int"),
+ &(instr_vtable->multiply_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "multiply_float"),
+ &(instr_vtable->multiply_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply"),
+ &(instr_vtable->i_multiply));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply_int"),
+ &(instr_vtable->i_multiply_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_multiply_float"),
+ &(instr_vtable->i_multiply_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "divide"),
+ &(instr_vtable->divide));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "divide_int"),
+ &(instr_vtable->divide_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "divide_float"),
+ &(instr_vtable->divide_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide"),
+ &(instr_vtable->i_divide));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide_int"),
+ &(instr_vtable->i_divide_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_divide_float"),
+ &(instr_vtable->i_divide_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide"),
+ &(instr_vtable->floor_divide));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide_int"),
+ &(instr_vtable->floor_divide_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "floor_divide_float"),
+ &(instr_vtable->floor_divide_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide"),
+ &(instr_vtable->i_floor_divide));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide_int"),
+ &(instr_vtable->i_floor_divide_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_floor_divide_float"),
+ &(instr_vtable->i_floor_divide_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus"),
+ &(instr_vtable->modulus));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus_int"),
+ &(instr_vtable->modulus_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "modulus_float"),
+ &(instr_vtable->modulus_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus"),
+ &(instr_vtable->i_modulus));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus_int"),
+ &(instr_vtable->i_modulus_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_modulus_float"),
+ &(instr_vtable->i_modulus_float));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "absolute"),
+ &(instr_vtable->absolute));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "neg"),
+ &(instr_vtable->neg));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal"),
+ &(instr_vtable->is_equal));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal_num"),
+ &(instr_vtable->is_equal_num));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "is_equal_string"),
+ &(instr_vtable->is_equal_string));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "is_same"),
+ &(instr_vtable->is_same));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp"),
+ &(instr_vtable->cmp));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_num"),
+ &(instr_vtable->cmp_num));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_string"),
+ &(instr_vtable->cmp_string));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "cmp_pmc"),
+ &(instr_vtable->cmp_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_or"),
+ &(instr_vtable->logical_or));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_and"),
+ &(instr_vtable->logical_and));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_xor"),
+ &(instr_vtable->logical_xor));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "logical_not"),
+ &(instr_vtable->logical_not));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "concatenate"),
+ &(instr_vtable->concatenate));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "concatenate_str"),
+ &(instr_vtable->concatenate_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_concatenate"),
+ &(instr_vtable->i_concatenate));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_concatenate_str"),
+ &(instr_vtable->i_concatenate_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "repeat"),
+ &(instr_vtable->repeat));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "repeat_int"),
+ &(instr_vtable->repeat_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_repeat"),
+ &(instr_vtable->i_repeat));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "i_repeat_int"),
+ &(instr_vtable->i_repeat_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "substr"),
+ &(instr_vtable->substr));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "substr_str"),
+ &(instr_vtable->substr_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed"),
+ &(instr_vtable->exists_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed_int"),
+ &(instr_vtable->exists_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "exists_keyed_str"),
+ &(instr_vtable->exists_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed"),
+ &(instr_vtable->defined_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed_int"),
+ &(instr_vtable->defined_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "defined_keyed_str"),
+ &(instr_vtable->defined_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed"),
+ &(instr_vtable->delete_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed_int"),
+ &(instr_vtable->delete_keyed_int));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "delete_keyed_str"),
+ &(instr_vtable->delete_keyed_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "invoke"),
+ &(instr_vtable->invoke));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "can"),
+ &(instr_vtable->can));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "does_pmc"),
+ &(instr_vtable->does_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "does"),
+ &(instr_vtable->does));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "isa_pmc"),
+ &(instr_vtable->isa_pmc));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "isa"),
+ &(instr_vtable->isa));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_attr_str"),
+ &(instr_vtable->get_attr_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "get_attr_keyed"),
+ &(instr_vtable->get_attr_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_attr_str"),
+ &(instr_vtable->set_attr_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "set_attr_keyed"),
+ &(instr_vtable->set_attr_keyed));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_parent"),
+ &(instr_vtable->add_parent));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_parent"),
+ &(instr_vtable->remove_parent));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_role"),
+ &(instr_vtable->add_role));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_role"),
+ &(instr_vtable->remove_role));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_attribute"),
+ &(instr_vtable->add_attribute));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_attribute"),
+ &(instr_vtable->remove_attribute));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_method"),
+ &(instr_vtable->add_method));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_method"),
+ &(instr_vtable->remove_method));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "add_vtable_override"),
+ &(instr_vtable->add_vtable_override));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "remove_vtable_override"),
+ &(instr_vtable->remove_vtable_override));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "inspect_str"),
+ &(instr_vtable->inspect_str));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "freeze"),
+ &(instr_vtable->freeze));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "thaw"),
+ &(instr_vtable->thaw));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "thawfinish"),
+ &(instr_vtable->thawfinish));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "visit"),
+ &(instr_vtable->visit));
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "init_int"),
+ &(instr_vtable->init_int));
+
/* Build mappings for name -> stub_function if it wasn't done already. */
if (parrot_hash_size(interp, stub) == 0) {
- parrot_hash_put(interp, stub, CONST_STRING(interp, "absolute"),
- stub_vtable_absolute);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add"),
- stub_vtable_add);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_attribute"),
- stub_vtable_add_attribute);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_float"),
- stub_vtable_add_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_int"),
- stub_vtable_add_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_method"),
- stub_vtable_add_method);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_parent"),
- stub_vtable_add_parent);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_role"),
- stub_vtable_add_role);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "add_vtable_override"),
- stub_vtable_add_vtable_override);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "assign_pmc"),
- stub_vtable_assign_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "assign_string_native"),
- stub_vtable_assign_string_native);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "can"),
- stub_vtable_can);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "clone"),
- stub_vtable_clone);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "clone_pmc"),
- stub_vtable_clone_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp"),
- stub_vtable_cmp);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_num"),
- stub_vtable_cmp_num);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_pmc"),
- stub_vtable_cmp_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_string"),
- stub_vtable_cmp_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "concatenate"),
- stub_vtable_concatenate);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "concatenate_str"),
- stub_vtable_concatenate_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "decrement"),
- stub_vtable_decrement);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "defined"),
- stub_vtable_defined);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed"),
- stub_vtable_defined_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed_int"),
- stub_vtable_defined_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed_str"),
- stub_vtable_defined_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed"),
- stub_vtable_delete_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed_int"),
- stub_vtable_delete_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed_str"),
- stub_vtable_delete_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "delprop"),
- stub_vtable_delprop);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "destroy"),
- stub_vtable_destroy);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "divide"),
- stub_vtable_divide);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "divide_float"),
- stub_vtable_divide_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "divide_int"),
- stub_vtable_divide_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "does"),
- stub_vtable_does);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "does_pmc"),
- stub_vtable_does_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "elements"),
- stub_vtable_elements);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed"),
- stub_vtable_exists_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed_int"),
- stub_vtable_exists_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed_str"),
- stub_vtable_exists_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "find_method"),
- stub_vtable_find_method);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide"),
- stub_vtable_floor_divide);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide_float"),
- stub_vtable_floor_divide_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide_int"),
- stub_vtable_floor_divide_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "freeze"),
- stub_vtable_freeze);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_attr_keyed"),
- stub_vtable_get_attr_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_attr_str"),
- stub_vtable_get_attr_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_bool"),
- stub_vtable_get_bool);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_class"),
- stub_vtable_get_class);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer"),
- stub_vtable_get_integer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed"),
- stub_vtable_get_integer_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed_int"),
- stub_vtable_get_integer_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed_str"),
- stub_vtable_get_integer_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_iter"),
- stub_vtable_get_iter);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_namespace"),
- stub_vtable_get_namespace);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number"),
- stub_vtable_get_number);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed"),
- stub_vtable_get_number_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed_int"),
- stub_vtable_get_number_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed_str"),
- stub_vtable_get_number_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc"),
- stub_vtable_get_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed"),
- stub_vtable_get_pmc_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed_int"),
- stub_vtable_get_pmc_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed_str"),
- stub_vtable_get_pmc_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer"),
- stub_vtable_get_pointer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed"),
- stub_vtable_get_pointer_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed_int"),
- stub_vtable_get_pointer_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed_str"),
- stub_vtable_get_pointer_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_repr"),
- stub_vtable_get_repr);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string"),
- stub_vtable_get_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed"),
- stub_vtable_get_string_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed_int"),
- stub_vtable_get_string_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed_str"),
- stub_vtable_get_string_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "getprop"),
- stub_vtable_getprop);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "getprops"),
- stub_vtable_getprops);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "hashvalue"),
- stub_vtable_hashvalue);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_absolute"),
- stub_vtable_i_absolute);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add"),
- stub_vtable_i_add);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add_float"),
- stub_vtable_i_add_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add_int"),
- stub_vtable_i_add_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_concatenate"),
- stub_vtable_i_concatenate);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_concatenate_str"),
- stub_vtable_i_concatenate_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide"),
- stub_vtable_i_divide);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide_float"),
- stub_vtable_i_divide_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide_int"),
- stub_vtable_i_divide_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide"),
- stub_vtable_i_floor_divide);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide_float"),
- stub_vtable_i_floor_divide_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide_int"),
- stub_vtable_i_floor_divide_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_logical_not"),
- stub_vtable_i_logical_not);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus"),
- stub_vtable_i_modulus);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus_float"),
- stub_vtable_i_modulus_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus_int"),
- stub_vtable_i_modulus_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply"),
- stub_vtable_i_multiply);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply_float"),
- stub_vtable_i_multiply_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply_int"),
- stub_vtable_i_multiply_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_neg"),
- stub_vtable_i_neg);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_repeat"),
- stub_vtable_i_repeat);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_repeat_int"),
- stub_vtable_i_repeat_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract"),
- stub_vtable_i_subtract);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract_float"),
- stub_vtable_i_subtract_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract_int"),
- stub_vtable_i_subtract_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "increment"),
- stub_vtable_increment);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "init"),
- stub_vtable_init);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "init_int"),
- stub_vtable_init_int);
parrot_hash_put(interp, stub, CONST_STRING(interp, "init_pmc"),
- stub_vtable_init_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "inspect"),
- stub_vtable_inspect);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "inspect_str"),
- stub_vtable_inspect_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "instantiate"),
- stub_vtable_instantiate);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "invoke"),
- stub_vtable_invoke);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal"),
- stub_vtable_is_equal);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal_num"),
- stub_vtable_is_equal_num);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal_string"),
- stub_vtable_is_equal_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "is_same"),
- stub_vtable_is_same);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "isa"),
- stub_vtable_isa);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "isa_pmc"),
- stub_vtable_isa_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_and"),
- stub_vtable_logical_and);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_not"),
- stub_vtable_logical_not);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_or"),
- stub_vtable_logical_or);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_xor"),
- stub_vtable_logical_xor);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "mark"),
- stub_vtable_mark);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus"),
- stub_vtable_modulus);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus_float"),
- stub_vtable_modulus_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus_int"),
- stub_vtable_modulus_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "morph"),
- stub_vtable_morph);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply"),
- stub_vtable_multiply);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply_float"),
- stub_vtable_multiply_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply_int"),
- stub_vtable_multiply_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "name"),
- stub_vtable_name);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "neg"),
- stub_vtable_neg);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "pop_float"),
- stub_vtable_pop_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "pop_integer"),
- stub_vtable_pop_integer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "pop_pmc"),
- stub_vtable_pop_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "pop_string"),
- stub_vtable_pop_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "push_float"),
- stub_vtable_push_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "push_integer"),
- stub_vtable_push_integer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "push_pmc"),
- stub_vtable_push_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "push_string"),
- stub_vtable_push_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_attribute"),
- stub_vtable_remove_attribute);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_method"),
- stub_vtable_remove_method);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_parent"),
- stub_vtable_remove_parent);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_role"),
- stub_vtable_remove_role);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_vtable_override"),
- stub_vtable_remove_vtable_override);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "repeat"),
- stub_vtable_repeat);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "repeat_int"),
- stub_vtable_repeat_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_attr_keyed"),
- stub_vtable_set_attr_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_attr_str"),
- stub_vtable_set_attr_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_bool"),
- stub_vtable_set_bool);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed"),
- stub_vtable_set_integer_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed_int"),
- stub_vtable_set_integer_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed_str"),
- stub_vtable_set_integer_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_native"),
- stub_vtable_set_integer_native);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed"),
- stub_vtable_set_number_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed_int"),
- stub_vtable_set_number_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed_str"),
- stub_vtable_set_number_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_native"),
- stub_vtable_set_number_native);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc"),
- stub_vtable_set_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed"),
- stub_vtable_set_pmc_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed_int"),
- stub_vtable_set_pmc_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed_str"),
- stub_vtable_set_pmc_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer"),
- stub_vtable_set_pointer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed"),
- stub_vtable_set_pointer_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed_int"),
- stub_vtable_set_pointer_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed_str"),
- stub_vtable_set_pointer_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed"),
- stub_vtable_set_string_keyed);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed_int"),
- stub_vtable_set_string_keyed_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed_str"),
- stub_vtable_set_string_keyed_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_native"),
- stub_vtable_set_string_native);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "setprop"),
- stub_vtable_setprop);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "share"),
- stub_vtable_share);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "share_ro"),
- stub_vtable_share_ro);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "shift_float"),
- stub_vtable_shift_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "shift_integer"),
- stub_vtable_shift_integer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "shift_pmc"),
- stub_vtable_shift_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "shift_string"),
- stub_vtable_shift_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "splice"),
- stub_vtable_splice);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "substr"),
- stub_vtable_substr);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "substr_str"),
- stub_vtable_substr_str);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract"),
- stub_vtable_subtract);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract_float"),
- stub_vtable_subtract_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract_int"),
- stub_vtable_subtract_int);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "thaw"),
- stub_vtable_thaw);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "thawfinish"),
- stub_vtable_thawfinish);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "type"),
- stub_vtable_type);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_float"),
- stub_vtable_unshift_float);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_integer"),
- stub_vtable_unshift_integer);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_pmc"),
- stub_vtable_unshift_pmc);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_string"),
- stub_vtable_unshift_string);
- parrot_hash_put(interp, stub, CONST_STRING(interp, "visit"),
- stub_vtable_visit);
+ stub_init_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "instantiate"),
+ stub_instantiate);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "morph"),
+ stub_morph);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "getprop"),
+ stub_getprop);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "setprop"),
+ stub_setprop);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "delprop"),
+ stub_delprop);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "clone_pmc"),
+ stub_clone_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "find_method"),
+ stub_find_method);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed"),
+ stub_get_integer_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed_int"),
+ stub_get_integer_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_integer_keyed_str"),
+ stub_get_integer_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed"),
+ stub_get_number_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed_int"),
+ stub_get_number_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_number_keyed_str"),
+ stub_get_number_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed"),
+ stub_get_string_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed_int"),
+ stub_get_string_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_string_keyed_str"),
+ stub_get_string_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed"),
+ stub_get_pmc_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed_int"),
+ stub_get_pmc_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pmc_keyed_str"),
+ stub_get_pmc_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed"),
+ stub_get_pointer_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed_int"),
+ stub_get_pointer_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_pointer_keyed_str"),
+ stub_get_pointer_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_native"),
+ stub_set_integer_native);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed"),
+ stub_set_integer_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed_int"),
+ stub_set_integer_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_integer_keyed_str"),
+ stub_set_integer_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_native"),
+ stub_set_number_native);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed"),
+ stub_set_number_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed_int"),
+ stub_set_number_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_number_keyed_str"),
+ stub_set_number_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_native"),
+ stub_set_string_native);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "assign_string_native"),
+ stub_assign_string_native);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed"),
+ stub_set_string_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed_int"),
+ stub_set_string_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_string_keyed_str"),
+ stub_set_string_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_bool"),
+ stub_set_bool);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc"),
+ stub_set_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "assign_pmc"),
+ stub_assign_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed"),
+ stub_set_pmc_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed_int"),
+ stub_set_pmc_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pmc_keyed_str"),
+ stub_set_pmc_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer"),
+ stub_set_pointer);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed"),
+ stub_set_pointer_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed_int"),
+ stub_set_pointer_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_pointer_keyed_str"),
+ stub_set_pointer_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "push_integer"),
+ stub_push_integer);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "push_float"),
+ stub_push_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "push_string"),
+ stub_push_string);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "push_pmc"),
+ stub_push_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_integer"),
+ stub_unshift_integer);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_float"),
+ stub_unshift_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_string"),
+ stub_unshift_string);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "unshift_pmc"),
+ stub_unshift_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "splice"),
+ stub_splice);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add"),
+ stub_add);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_int"),
+ stub_add_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_float"),
+ stub_add_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add"),
+ stub_i_add);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add_int"),
+ stub_i_add_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_add_float"),
+ stub_i_add_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract"),
+ stub_subtract);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract_int"),
+ stub_subtract_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "subtract_float"),
+ stub_subtract_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract"),
+ stub_i_subtract);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract_int"),
+ stub_i_subtract_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_subtract_float"),
+ stub_i_subtract_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply"),
+ stub_multiply);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply_int"),
+ stub_multiply_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "multiply_float"),
+ stub_multiply_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply"),
+ stub_i_multiply);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply_int"),
+ stub_i_multiply_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_multiply_float"),
+ stub_i_multiply_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "divide"),
+ stub_divide);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "divide_int"),
+ stub_divide_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "divide_float"),
+ stub_divide_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide"),
+ stub_i_divide);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide_int"),
+ stub_i_divide_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_divide_float"),
+ stub_i_divide_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide"),
+ stub_floor_divide);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide_int"),
+ stub_floor_divide_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "floor_divide_float"),
+ stub_floor_divide_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide"),
+ stub_i_floor_divide);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide_int"),
+ stub_i_floor_divide_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_floor_divide_float"),
+ stub_i_floor_divide_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus"),
+ stub_modulus);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus_int"),
+ stub_modulus_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "modulus_float"),
+ stub_modulus_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus"),
+ stub_i_modulus);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus_int"),
+ stub_i_modulus_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_modulus_float"),
+ stub_i_modulus_float);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "absolute"),
+ stub_absolute);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "neg"),
+ stub_neg);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal"),
+ stub_is_equal);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal_num"),
+ stub_is_equal_num);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "is_equal_string"),
+ stub_is_equal_string);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "is_same"),
+ stub_is_same);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp"),
+ stub_cmp);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_num"),
+ stub_cmp_num);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_string"),
+ stub_cmp_string);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "cmp_pmc"),
+ stub_cmp_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_or"),
+ stub_logical_or);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_and"),
+ stub_logical_and);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_xor"),
+ stub_logical_xor);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "logical_not"),
+ stub_logical_not);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "concatenate"),
+ stub_concatenate);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "concatenate_str"),
+ stub_concatenate_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_concatenate"),
+ stub_i_concatenate);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_concatenate_str"),
+ stub_i_concatenate_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "repeat"),
+ stub_repeat);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "repeat_int"),
+ stub_repeat_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_repeat"),
+ stub_i_repeat);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "i_repeat_int"),
+ stub_i_repeat_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "substr"),
+ stub_substr);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "substr_str"),
+ stub_substr_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed"),
+ stub_exists_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed_int"),
+ stub_exists_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "exists_keyed_str"),
+ stub_exists_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed"),
+ stub_defined_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed_int"),
+ stub_defined_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "defined_keyed_str"),
+ stub_defined_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed"),
+ stub_delete_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed_int"),
+ stub_delete_keyed_int);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "delete_keyed_str"),
+ stub_delete_keyed_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "invoke"),
+ stub_invoke);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "can"),
+ stub_can);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "does_pmc"),
+ stub_does_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "does"),
+ stub_does);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "isa_pmc"),
+ stub_isa_pmc);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "isa"),
+ stub_isa);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_attr_str"),
+ stub_get_attr_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "get_attr_keyed"),
+ stub_get_attr_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_attr_str"),
+ stub_set_attr_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "set_attr_keyed"),
+ stub_set_attr_keyed);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_parent"),
+ stub_add_parent);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_parent"),
+ stub_remove_parent);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_role"),
+ stub_add_role);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_role"),
+ stub_remove_role);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_attribute"),
+ stub_add_attribute);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_attribute"),
+ stub_remove_attribute);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_method"),
+ stub_add_method);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_method"),
+ stub_remove_method);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "add_vtable_override"),
+ stub_add_vtable_override);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "remove_vtable_override"),
+ stub_remove_vtable_override);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "inspect_str"),
+ stub_inspect_str);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "freeze"),
+ stub_freeze);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "thaw"),
+ stub_thaw);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "thawfinish"),
+ stub_thawfinish);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "visit"),
+ stub_visit);
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "init_int"),
+ stub_init_int);
+
}
+
/* END vtable mappings */
}
@@ -1503,29 +1255,28 @@
/* BEGIN vtable stubs */
static
-PMC* stub_vtable_absolute(PARROT_INTERP, PMC* pmc, PMC* dest) {
+void stub_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->absolute(interp, pmc, dest);
+ orig_vtable->init_pmc(interp, pmc, initializer);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "absolute"));
+ CONST_STRING(supervisor, "init_pmc"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_add(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -1536,39 +1287,39 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->add(interp, pmc, value, dest);
+ ret = orig_vtable->instantiate(interp, pmc, sig);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add"));
+ CONST_STRING(supervisor, "instantiate"));
return ret;
}
static
-void stub_vtable_add_attribute(PARROT_INTERP, PMC* pmc, STRING* name, PMC* type) {
+void stub_morph(PARROT_INTERP, PMC* pmc, PMC* type) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->add_attribute(interp, pmc, name, type);
+ orig_vtable->morph(interp, pmc, type);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_attribute"));
+ CONST_STRING(supervisor, "morph"));
return;
}
static
-PMC* stub_vtable_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
+PMC* stub_getprop(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -1579,320 +1330,324 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->add_float(interp, pmc, value, dest);
+ ret = orig_vtable->getprop(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_float"));
+ CONST_STRING(supervisor, "getprop"));
return ret;
}
static
-PMC* stub_vtable_add_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+void stub_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->add_int(interp, pmc, value, dest);
+ orig_vtable->setprop(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_int"));
+ CONST_STRING(supervisor, "setprop"));
- return ret;
+ return;
}
static
-void stub_vtable_add_method(PARROT_INTERP, PMC* pmc, STRING* method_name, PMC* sub_pmc) {
+void stub_delprop(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->add_method(interp, pmc, method_name, sub_pmc);
+ orig_vtable->delprop(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_method"));
+ CONST_STRING(supervisor, "delprop"));
return;
}
static
-void stub_vtable_add_parent(PARROT_INTERP, PMC* pmc, PMC* parent) {
+PMC* stub_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->add_parent(interp, pmc, parent);
+ ret = orig_vtable->clone_pmc(interp, pmc, args);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_parent"));
+ CONST_STRING(supervisor, "clone_pmc"));
- return;
+ return ret;
}
static
-void stub_vtable_add_role(PARROT_INTERP, PMC* pmc, PMC* role) {
+PMC* stub_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->add_role(interp, pmc, role);
+ ret = orig_vtable->find_method(interp, pmc, method_name);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_role"));
+ CONST_STRING(supervisor, "find_method"));
- return;
+ return ret;
}
static
-void stub_vtable_add_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name, PMC* sub_pmc) {
+INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->add_vtable_override(interp, pmc, vtable_name, sub_pmc);
+ ret = orig_vtable->get_integer_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "add_vtable_override"));
+ CONST_STRING(supervisor, "get_integer_keyed"));
- return;
+ return ret;
}
static
-void stub_vtable_assign_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->assign_pmc(interp, pmc, value);
+ ret = orig_vtable->get_integer_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "assign_pmc"));
+ CONST_STRING(supervisor, "get_integer_keyed_int"));
- return;
+ return ret;
}
static
-void stub_vtable_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
+INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->assign_string_native(interp, pmc, value);
+ ret = orig_vtable->get_integer_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "assign_string_native"));
+ CONST_STRING(supervisor, "get_integer_keyed_str"));
- return;
+ return ret;
}
static
-INTVAL stub_vtable_can(PARROT_INTERP, PMC* pmc, STRING* method) {
+FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->can(interp, pmc, method);
+ ret = orig_vtable->get_number_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "can"));
+ CONST_STRING(supervisor, "get_number_keyed"));
return ret;
}
static
-PMC* stub_vtable_clone(PARROT_INTERP, PMC* pmc) {
+FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->clone(interp, pmc);
+ ret = orig_vtable->get_number_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "clone"));
+ CONST_STRING(supervisor, "get_number_keyed_int"));
return ret;
}
static
-PMC* stub_vtable_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args) {
+FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->clone_pmc(interp, pmc, args);
+ ret = orig_vtable->get_number_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "clone_pmc"));
+ CONST_STRING(supervisor, "get_number_keyed_str"));
return ret;
}
static
-INTVAL stub_vtable_cmp(PARROT_INTERP, PMC* pmc, PMC* value) {
+STRING* stub_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->cmp(interp, pmc, value);
+ ret = orig_vtable->get_string_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "cmp"));
+ CONST_STRING(supervisor, "get_string_keyed"));
return ret;
}
static
-INTVAL stub_vtable_cmp_num(PARROT_INTERP, PMC* pmc, PMC* value) {
+STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->cmp_num(interp, pmc, value);
+ ret = orig_vtable->get_string_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "cmp_num"));
+ CONST_STRING(supervisor, "get_string_keyed_int"));
return ret;
}
static
-PMC* stub_vtable_cmp_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->cmp_pmc(interp, pmc, value);
+ ret = orig_vtable->get_string_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "cmp_pmc"));
+ CONST_STRING(supervisor, "get_string_keyed_str"));
return ret;
}
static
-INTVAL stub_vtable_cmp_string(PARROT_INTERP, PMC* pmc, PMC* value) {
+PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->cmp_string(interp, pmc, value);
+ ret = orig_vtable->get_pmc_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "cmp_string"));
+ CONST_STRING(supervisor, "get_pmc_keyed"));
return ret;
}
static
-PMC* stub_vtable_concatenate(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -1903,18 +1658,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->concatenate(interp, pmc, value, dest);
+ ret = orig_vtable->get_pmc_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "concatenate"));
+ CONST_STRING(supervisor, "get_pmc_keyed_int"));
return ret;
}
static
-PMC* stub_vtable_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value, PMC* dest) {
+PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -1925,1808 +1680,1014 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->concatenate_str(interp, pmc, value, dest);
+ ret = orig_vtable->get_pmc_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "concatenate_str"));
+ CONST_STRING(supervisor, "get_pmc_keyed_str"));
return ret;
}
static
-void stub_vtable_decrement(PARROT_INTERP, PMC* pmc) {
+void* stub_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->decrement(interp, pmc);
+ ret = orig_vtable->get_pointer_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "decrement"));
+ CONST_STRING(supervisor, "get_pointer_keyed"));
- return;
+ return ret;
}
static
-INTVAL stub_vtable_defined(PARROT_INTERP, PMC* pmc) {
+void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->defined(interp, pmc);
+ ret = orig_vtable->get_pointer_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "defined"));
+ CONST_STRING(supervisor, "get_pointer_keyed_int"));
return ret;
}
static
-INTVAL stub_vtable_defined_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->defined_keyed(interp, pmc, key);
+ ret = orig_vtable->get_pointer_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "defined_keyed"));
+ CONST_STRING(supervisor, "get_pointer_keyed_str"));
return ret;
}
static
-INTVAL stub_vtable_defined_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_integer_native(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->defined_keyed_int(interp, pmc, key);
+ orig_vtable->set_integer_native(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "defined_keyed_int"));
+ CONST_STRING(supervisor, "set_integer_native"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_defined_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->defined_keyed_str(interp, pmc, key);
+ orig_vtable->set_integer_keyed(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "defined_keyed_str"));
+ CONST_STRING(supervisor, "set_integer_keyed"));
- return ret;
+ return;
}
static
-void stub_vtable_delete_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void stub_set_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->delete_keyed(interp, pmc, key);
+ orig_vtable->set_integer_keyed_int(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "delete_keyed"));
+ CONST_STRING(supervisor, "set_integer_keyed_int"));
return;
}
static
-void stub_vtable_delete_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->delete_keyed_int(interp, pmc, key);
+ orig_vtable->set_integer_keyed_str(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "delete_keyed_int"));
+ CONST_STRING(supervisor, "set_integer_keyed_str"));
return;
}
static
-void stub_vtable_delete_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->delete_keyed_str(interp, pmc, key);
+ orig_vtable->set_number_native(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "delete_keyed_str"));
+ CONST_STRING(supervisor, "set_number_native"));
return;
}
static
-void stub_vtable_delprop(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->delprop(interp, pmc, key);
+ orig_vtable->set_number_keyed(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "delprop"));
+ CONST_STRING(supervisor, "set_number_keyed"));
return;
}
static
-void stub_vtable_destroy(PARROT_INTERP, PMC* pmc) {
+void stub_set_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->destroy(interp, pmc);
+ orig_vtable->set_number_keyed_int(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "destroy"));
+ CONST_STRING(supervisor, "set_number_keyed_int"));
return;
}
static
-PMC* stub_vtable_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+void stub_set_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->divide(interp, pmc, value, dest);
+ orig_vtable->set_number_keyed_str(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "divide"));
+ CONST_STRING(supervisor, "set_number_keyed_str"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
+void stub_set_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->divide_float(interp, pmc, value, dest);
+ orig_vtable->set_string_native(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "divide_float"));
+ CONST_STRING(supervisor, "set_string_native"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+void stub_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->divide_int(interp, pmc, value, dest);
+ orig_vtable->assign_string_native(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "divide_int"));
+ CONST_STRING(supervisor, "assign_string_native"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_does(PARROT_INTERP, PMC* pmc, STRING* role) {
+void stub_set_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->does(interp, pmc, role);
+ orig_vtable->set_string_keyed(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "does"));
+ CONST_STRING(supervisor, "set_string_keyed"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_does_pmc(PARROT_INTERP, PMC* pmc, PMC* role) {
+void stub_set_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->does_pmc(interp, pmc, role);
+ orig_vtable->set_string_keyed_int(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "does_pmc"));
+ CONST_STRING(supervisor, "set_string_keyed_int"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_elements(PARROT_INTERP, PMC* pmc) {
+void stub_set_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->elements(interp, pmc);
+ orig_vtable->set_string_keyed_str(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "elements"));
+ CONST_STRING(supervisor, "set_string_keyed_str"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_exists_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void stub_set_bool(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->exists_keyed(interp, pmc, key);
+ orig_vtable->set_bool(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "exists_keyed"));
+ CONST_STRING(supervisor, "set_bool"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_exists_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->exists_keyed_int(interp, pmc, key);
+ orig_vtable->set_pmc(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "exists_keyed_int"));
+ CONST_STRING(supervisor, "set_pmc"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_exists_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_assign_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->exists_keyed_str(interp, pmc, key);
+ orig_vtable->assign_pmc(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "exists_keyed_str"));
+ CONST_STRING(supervisor, "assign_pmc"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
+void stub_set_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->find_method(interp, pmc, method_name);
+ orig_vtable->set_pmc_keyed(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "find_method"));
+ CONST_STRING(supervisor, "set_pmc_keyed"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+void stub_set_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->floor_divide(interp, pmc, value, dest);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "floor_divide"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->floor_divide_float(interp, pmc, value, dest);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "floor_divide_float"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->floor_divide_int(interp, pmc, value, dest);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "floor_divide_int"));
-
- return ret;
-}
-
-static
-void stub_vtable_freeze(PARROT_INTERP, PMC* pmc, PMC* info) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- orig_vtable->freeze(interp, pmc, info);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "freeze"));
-
- return;
-}
-
-static
-PMC* stub_vtable_get_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_attr_keyed(interp, pmc, key, idx);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_attr_keyed"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_attr_str(interp, pmc, idx);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_attr_str"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_get_bool(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_bool(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_bool"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_class(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_class(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_class"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_get_integer(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_integer(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_integer"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_integer_keyed(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_integer_keyed"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_integer_keyed_int(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_integer_keyed_int"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_integer_keyed_str(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_integer_keyed_str"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_iter(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_iter(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_iter"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_namespace(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_namespace(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_namespace"));
-
- return ret;
-}
-
-static
-FLOATVAL stub_vtable_get_number(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- FLOATVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_number(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_number"));
-
- return ret;
-}
-
-static
-FLOATVAL stub_vtable_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- FLOATVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_number_keyed(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_number_keyed"));
-
- return ret;
-}
-
-static
-FLOATVAL stub_vtable_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- FLOATVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_number_keyed_int(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_number_keyed_int"));
-
- return ret;
-}
-
-static
-FLOATVAL stub_vtable_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- FLOATVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_number_keyed_str(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_number_keyed_str"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_pmc(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pmc(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pmc"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pmc_keyed(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pmc_keyed"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pmc_keyed_int(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pmc_keyed_int"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pmc_keyed_str(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pmc_keyed_str"));
-
- return ret;
-}
-
-static
-void* stub_vtable_get_pointer(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- void* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pointer(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pointer"));
-
- return ret;
-}
-
-static
-void* stub_vtable_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- void* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pointer_keyed(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pointer_keyed"));
-
- return ret;
-}
-
-static
-void* stub_vtable_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- void* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pointer_keyed_int(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pointer_keyed_int"));
-
- return ret;
-}
-
-static
-void* stub_vtable_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- void* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_pointer_keyed_str(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_pointer_keyed_str"));
-
- return ret;
-}
-
-static
-STRING* stub_vtable_get_repr(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- STRING* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_repr(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_repr"));
-
- return ret;
-}
-
-static
-STRING* stub_vtable_get_string(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- STRING* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_string(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_string"));
-
- return ret;
-}
-
-static
-STRING* stub_vtable_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- STRING* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_string_keyed(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_string_keyed"));
-
- return ret;
-}
-
-static
-STRING* stub_vtable_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- STRING* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_string_keyed_int(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_string_keyed_int"));
-
- return ret;
-}
-
-static
-STRING* stub_vtable_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- STRING* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->get_string_keyed_str(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "get_string_keyed_str"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_getprop(PARROT_INTERP, PMC* pmc, STRING* key) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->getprop(interp, pmc, key);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "getprop"));
-
- return ret;
-}
-
-static
-PMC* stub_vtable_getprops(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- PMC* ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->getprops(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "getprops"));
-
- return ret;
-}
-
-static
-INTVAL stub_vtable_hashvalue(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
- INTVAL ret;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- ret = orig_vtable->hashvalue(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "hashvalue"));
-
- return ret;
-}
-
-static
-void stub_vtable_i_absolute(PARROT_INTERP, PMC* pmc) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- orig_vtable->i_absolute(interp, pmc);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_absolute"));
-
- return;
-}
-
-static
-void stub_vtable_i_add(PARROT_INTERP, PMC* pmc, PMC* value) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- orig_vtable->i_add(interp, pmc, value);
-
- data = Parrot_pmc_new(supervisor, enum_class_Hash);
-
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_add"));
-
- return;
-}
-
-static
-void stub_vtable_i_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
- PMC *instr_vt, *data;
- _vtable *orig_vtable;
- Parrot_Interp supervisor;
-
- instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
-
- GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
- GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
-
- orig_vtable->i_add_float(interp, pmc, value);
+ orig_vtable->set_pmc_keyed_int(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_add_float"));
+ CONST_STRING(supervisor, "set_pmc_keyed_int"));
return;
}
static
-void stub_vtable_i_add_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_set_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_add_int(interp, pmc, value);
+ orig_vtable->set_pmc_keyed_str(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_add_int"));
+ CONST_STRING(supervisor, "set_pmc_keyed_str"));
return;
}
static
-void stub_vtable_i_concatenate(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_set_pointer(PARROT_INTERP, PMC* pmc, void* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_concatenate(interp, pmc, value);
+ orig_vtable->set_pointer(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_concatenate"));
+ CONST_STRING(supervisor, "set_pointer"));
return;
}
static
-void stub_vtable_i_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value) {
+void stub_set_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, void* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_concatenate_str(interp, pmc, value);
+ orig_vtable->set_pointer_keyed(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_concatenate_str"));
+ CONST_STRING(supervisor, "set_pointer_keyed"));
return;
}
static
-void stub_vtable_i_divide(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_set_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, void* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_divide(interp, pmc, value);
+ orig_vtable->set_pointer_keyed_int(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_divide"));
+ CONST_STRING(supervisor, "set_pointer_keyed_int"));
return;
}
static
-void stub_vtable_i_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_set_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, void* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_divide_float(interp, pmc, value);
+ orig_vtable->set_pointer_keyed_str(interp, pmc, key, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_divide_float"));
+ CONST_STRING(supervisor, "set_pointer_keyed_str"));
return;
}
static
-void stub_vtable_i_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_divide_int(interp, pmc, value);
+ orig_vtable->push_integer(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_divide_int"));
+ CONST_STRING(supervisor, "push_integer"));
return;
}
static
-void stub_vtable_i_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_floor_divide(interp, pmc, value);
+ orig_vtable->push_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_floor_divide"));
+ CONST_STRING(supervisor, "push_float"));
return;
}
static
-void stub_vtable_i_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_push_string(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_floor_divide_float(interp, pmc, value);
+ orig_vtable->push_string(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_floor_divide_float"));
+ CONST_STRING(supervisor, "push_string"));
return;
}
static
-void stub_vtable_i_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_floor_divide_int(interp, pmc, value);
+ orig_vtable->push_pmc(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_floor_divide_int"));
+ CONST_STRING(supervisor, "push_pmc"));
return;
}
static
-void stub_vtable_i_logical_not(PARROT_INTERP, PMC* pmc) {
+void stub_unshift_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_logical_not(interp, pmc);
+ orig_vtable->unshift_integer(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_logical_not"));
+ CONST_STRING(supervisor, "unshift_integer"));
return;
}
static
-void stub_vtable_i_modulus(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_unshift_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_modulus(interp, pmc, value);
+ orig_vtable->unshift_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_modulus"));
+ CONST_STRING(supervisor, "unshift_float"));
return;
}
static
-void stub_vtable_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_unshift_string(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_modulus_float(interp, pmc, value);
+ orig_vtable->unshift_string(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_modulus_float"));
+ CONST_STRING(supervisor, "unshift_string"));
return;
}
static
-void stub_vtable_i_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_unshift_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_modulus_int(interp, pmc, value);
+ orig_vtable->unshift_pmc(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_modulus_int"));
+ CONST_STRING(supervisor, "unshift_pmc"));
return;
}
static
-void stub_vtable_i_multiply(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_splice(PARROT_INTERP, PMC* pmc, PMC* value, INTVAL offset, INTVAL count) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_multiply(interp, pmc, value);
+ orig_vtable->splice(interp, pmc, value, offset, count);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_multiply"));
+ CONST_STRING(supervisor, "splice"));
return;
}
static
-void stub_vtable_i_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+PMC* stub_add(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_multiply_float(interp, pmc, value);
+ ret = orig_vtable->add(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_multiply_float"));
+ CONST_STRING(supervisor, "add"));
- return;
+ return ret;
}
static
-void stub_vtable_i_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+PMC* stub_add_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_multiply_int(interp, pmc, value);
+ ret = orig_vtable->add_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_multiply_int"));
+ CONST_STRING(supervisor, "add_int"));
- return;
+ return ret;
}
static
-void stub_vtable_i_neg(PARROT_INTERP, PMC* pmc) {
+PMC* stub_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_neg(interp, pmc);
+ ret = orig_vtable->add_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_neg"));
+ CONST_STRING(supervisor, "add_float"));
- return;
+ return ret;
}
static
-void stub_vtable_i_repeat(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_i_add(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_repeat(interp, pmc, value);
+ orig_vtable->i_add(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_repeat"));
+ CONST_STRING(supervisor, "i_add"));
return;
}
static
-void stub_vtable_i_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_i_add_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_repeat_int(interp, pmc, value);
+ orig_vtable->i_add_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_repeat_int"));
+ CONST_STRING(supervisor, "i_add_int"));
return;
}
static
-void stub_vtable_i_subtract(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_i_add_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_subtract(interp, pmc, value);
+ orig_vtable->i_add_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_subtract"));
+ CONST_STRING(supervisor, "i_add_float"));
return;
}
static
-void stub_vtable_i_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+PMC* stub_subtract(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_subtract_float(interp, pmc, value);
+ ret = orig_vtable->subtract(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_subtract_float"));
+ CONST_STRING(supervisor, "subtract"));
- return;
+ return ret;
}
static
-void stub_vtable_i_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
+PMC* stub_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->i_subtract_int(interp, pmc, value);
+ ret = orig_vtable->subtract_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "i_subtract_int"));
+ CONST_STRING(supervisor, "subtract_int"));
- return;
+ return ret;
}
static
-void stub_vtable_increment(PARROT_INTERP, PMC* pmc) {
+PMC* stub_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->increment(interp, pmc);
+ ret = orig_vtable->subtract_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "increment"));
+ CONST_STRING(supervisor, "subtract_float"));
- return;
+ return ret;
}
static
-void stub_vtable_init(PARROT_INTERP, PMC* pmc) {
+void stub_i_subtract(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->init(interp, pmc);
+ orig_vtable->i_subtract(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "init"));
+ CONST_STRING(supervisor, "i_subtract"));
return;
}
static
-void stub_vtable_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer) {
+void stub_i_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->init_int(interp, pmc, initializer);
+ orig_vtable->i_subtract_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "init_int"));
+ CONST_STRING(supervisor, "i_subtract_int"));
return;
}
static
-void stub_vtable_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer) {
+void stub_i_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->init_pmc(interp, pmc, initializer);
+ orig_vtable->i_subtract_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "init_pmc"));
+ CONST_STRING(supervisor, "i_subtract_float"));
return;
}
static
-PMC* stub_vtable_inspect(PARROT_INTERP, PMC* pmc) {
+PMC* stub_multiply(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -3737,18 +2698,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->inspect(interp, pmc);
+ ret = orig_vtable->multiply(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "inspect"));
+ CONST_STRING(supervisor, "multiply"));
return ret;
}
static
-PMC* stub_vtable_inspect_str(PARROT_INTERP, PMC* pmc, STRING* what) {
+PMC* stub_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -3759,18 +2720,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->inspect_str(interp, pmc, what);
+ ret = orig_vtable->multiply_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "inspect_str"));
+ CONST_STRING(supervisor, "multiply_int"));
return ret;
}
static
-PMC* stub_vtable_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig) {
+PMC* stub_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -3781,216 +2742,210 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->instantiate(interp, pmc, sig);
+ ret = orig_vtable->multiply_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "instantiate"));
+ CONST_STRING(supervisor, "multiply_float"));
return ret;
}
static
-opcode_t* stub_vtable_invoke(PARROT_INTERP, PMC* pmc, void* next) {
+void stub_i_multiply(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- opcode_t* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->invoke(interp, pmc, next);
+ orig_vtable->i_multiply(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "invoke"));
+ CONST_STRING(supervisor, "i_multiply"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_is_equal(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_i_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->is_equal(interp, pmc, value);
+ orig_vtable->i_multiply_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "is_equal"));
+ CONST_STRING(supervisor, "i_multiply_int"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_is_equal_num(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_i_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->is_equal_num(interp, pmc, value);
+ orig_vtable->i_multiply_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "is_equal_num"));
+ CONST_STRING(supervisor, "i_multiply_float"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_is_equal_string(PARROT_INTERP, PMC* pmc, PMC* value) {
+PMC* stub_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->is_equal_string(interp, pmc, value);
+ ret = orig_vtable->divide(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "is_equal_string"));
+ CONST_STRING(supervisor, "divide"));
return ret;
}
static
-INTVAL stub_vtable_is_same(PARROT_INTERP, PMC* pmc, PMC* value) {
+PMC* stub_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->is_same(interp, pmc, value);
+ ret = orig_vtable->divide_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "is_same"));
+ CONST_STRING(supervisor, "divide_int"));
return ret;
}
static
-INTVAL stub_vtable_isa(PARROT_INTERP, PMC* pmc, STRING* _class) {
+PMC* stub_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->isa(interp, pmc, _class);
+ ret = orig_vtable->divide_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "isa"));
+ CONST_STRING(supervisor, "divide_float"));
return ret;
}
static
-INTVAL stub_vtable_isa_pmc(PARROT_INTERP, PMC* pmc, PMC* _class) {
+void stub_i_divide(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->isa_pmc(interp, pmc, _class);
+ orig_vtable->i_divide(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "isa_pmc"));
+ CONST_STRING(supervisor, "i_divide"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_logical_and(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+void stub_i_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->logical_and(interp, pmc, value, dest);
+ orig_vtable->i_divide_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "logical_and"));
+ CONST_STRING(supervisor, "i_divide_int"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_logical_not(PARROT_INTERP, PMC* pmc, PMC* dest) {
+void stub_i_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->logical_not(interp, pmc, dest);
+ orig_vtable->i_divide_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "logical_not"));
+ CONST_STRING(supervisor, "i_divide_float"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_logical_or(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4001,18 +2956,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->logical_or(interp, pmc, value, dest);
+ ret = orig_vtable->floor_divide(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "logical_or"));
+ CONST_STRING(supervisor, "floor_divide"));
return ret;
}
static
-PMC* stub_vtable_logical_xor(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4023,126 +2978,125 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->logical_xor(interp, pmc, value, dest);
+ ret = orig_vtable->floor_divide_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "logical_xor"));
+ CONST_STRING(supervisor, "floor_divide_int"));
return ret;
}
static
-void stub_vtable_mark(PARROT_INTERP, PMC* pmc) {
+PMC* stub_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->mark(interp, pmc);
+ ret = orig_vtable->floor_divide_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "mark"));
+ CONST_STRING(supervisor, "floor_divide_float"));
- return;
+ return ret;
}
static
-PMC* stub_vtable_modulus(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+void stub_i_floor_divide(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->modulus(interp, pmc, value, dest);
+ orig_vtable->i_floor_divide(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "modulus"));
+ CONST_STRING(supervisor, "i_floor_divide"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
+void stub_i_floor_divide_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->modulus_float(interp, pmc, value, dest);
+ orig_vtable->i_floor_divide_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "modulus_float"));
+ CONST_STRING(supervisor, "i_floor_divide_int"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+void stub_i_floor_divide_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->modulus_int(interp, pmc, value, dest);
+ orig_vtable->i_floor_divide_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "modulus_int"));
+ CONST_STRING(supervisor, "i_floor_divide_float"));
- return ret;
+ return;
}
static
-void stub_vtable_morph(PARROT_INTERP, PMC* pmc, PMC* type) {
+PMC* stub_modulus(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->morph(interp, pmc, type);
+ ret = orig_vtable->modulus(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "morph"));
+ CONST_STRING(supervisor, "modulus"));
- return;
+ return ret;
}
static
-PMC* stub_vtable_multiply(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4153,18 +3107,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->multiply(interp, pmc, value, dest);
+ ret = orig_vtable->modulus_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "multiply"));
+ CONST_STRING(supervisor, "modulus_int"));
return ret;
}
static
-PMC* stub_vtable_multiply_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
+PMC* stub_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4175,361 +3129,367 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->multiply_float(interp, pmc, value, dest);
+ ret = orig_vtable->modulus_float(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "multiply_float"));
+ CONST_STRING(supervisor, "modulus_float"));
return ret;
}
static
-PMC* stub_vtable_multiply_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+void stub_i_modulus(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->multiply_int(interp, pmc, value, dest);
+ orig_vtable->i_modulus(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "multiply_int"));
+ CONST_STRING(supervisor, "i_modulus"));
- return ret;
+ return;
}
static
-STRING* stub_vtable_name(PARROT_INTERP, PMC* pmc) {
+void stub_i_modulus_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- STRING* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->name(interp, pmc);
+ orig_vtable->i_modulus_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "name"));
+ CONST_STRING(supervisor, "i_modulus_int"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_neg(PARROT_INTERP, PMC* pmc, PMC* dest) {
+void stub_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->neg(interp, pmc, dest);
+ orig_vtable->i_modulus_float(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "neg"));
+ CONST_STRING(supervisor, "i_modulus_float"));
- return ret;
+ return;
}
static
-FLOATVAL stub_vtable_pop_float(PARROT_INTERP, PMC* pmc) {
+PMC* stub_absolute(PARROT_INTERP, PMC* pmc, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- FLOATVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->pop_float(interp, pmc);
+ ret = orig_vtable->absolute(interp, pmc, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "pop_float"));
+ CONST_STRING(supervisor, "absolute"));
return ret;
}
static
-INTVAL stub_vtable_pop_integer(PARROT_INTERP, PMC* pmc) {
+PMC* stub_neg(PARROT_INTERP, PMC* pmc, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->pop_integer(interp, pmc);
+ ret = orig_vtable->neg(interp, pmc, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "pop_integer"));
+ CONST_STRING(supervisor, "neg"));
return ret;
}
static
-PMC* stub_vtable_pop_pmc(PARROT_INTERP, PMC* pmc) {
+INTVAL stub_is_equal(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->pop_pmc(interp, pmc);
+ ret = orig_vtable->is_equal(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "pop_pmc"));
+ CONST_STRING(supervisor, "is_equal"));
return ret;
}
static
-STRING* stub_vtable_pop_string(PARROT_INTERP, PMC* pmc) {
+INTVAL stub_is_equal_num(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- STRING* ret;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->pop_string(interp, pmc);
+ ret = orig_vtable->is_equal_num(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "pop_string"));
+ CONST_STRING(supervisor, "is_equal_num"));
return ret;
}
static
-void stub_vtable_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+INTVAL stub_is_equal_string(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->push_float(interp, pmc, value);
+ ret = orig_vtable->is_equal_string(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "push_float"));
+ CONST_STRING(supervisor, "is_equal_string"));
- return;
+ return ret;
}
static
-void stub_vtable_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
+INTVAL stub_is_same(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->push_integer(interp, pmc, value);
+ ret = orig_vtable->is_same(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "push_integer"));
+ CONST_STRING(supervisor, "is_same"));
- return;
+ return ret;
}
static
-void stub_vtable_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+INTVAL stub_cmp(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->push_pmc(interp, pmc, value);
+ ret = orig_vtable->cmp(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "push_pmc"));
+ CONST_STRING(supervisor, "cmp"));
- return;
+ return ret;
}
static
-void stub_vtable_push_string(PARROT_INTERP, PMC* pmc, STRING* value) {
+INTVAL stub_cmp_num(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->push_string(interp, pmc, value);
+ ret = orig_vtable->cmp_num(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "push_string"));
+ CONST_STRING(supervisor, "cmp_num"));
- return;
+ return ret;
}
static
-void stub_vtable_remove_attribute(PARROT_INTERP, PMC* pmc, STRING* name) {
+INTVAL stub_cmp_string(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->remove_attribute(interp, pmc, name);
+ ret = orig_vtable->cmp_string(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "remove_attribute"));
+ CONST_STRING(supervisor, "cmp_string"));
- return;
+ return ret;
}
static
-void stub_vtable_remove_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
+PMC* stub_cmp_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->remove_method(interp, pmc, method_name);
+ ret = orig_vtable->cmp_pmc(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "remove_method"));
+ CONST_STRING(supervisor, "cmp_pmc"));
- return;
+ return ret;
}
static
-void stub_vtable_remove_parent(PARROT_INTERP, PMC* pmc, PMC* parent) {
+PMC* stub_logical_or(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->remove_parent(interp, pmc, parent);
+ ret = orig_vtable->logical_or(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "remove_parent"));
+ CONST_STRING(supervisor, "logical_or"));
- return;
+ return ret;
}
static
-void stub_vtable_remove_role(PARROT_INTERP, PMC* pmc, PMC* role) {
+PMC* stub_logical_and(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->remove_role(interp, pmc, role);
+ ret = orig_vtable->logical_and(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "remove_role"));
+ CONST_STRING(supervisor, "logical_and"));
- return;
+ return ret;
}
static
-void stub_vtable_remove_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name) {
+PMC* stub_logical_xor(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->remove_vtable_override(interp, pmc, vtable_name);
+ ret = orig_vtable->logical_xor(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "remove_vtable_override"));
+ CONST_STRING(supervisor, "logical_xor"));
- return;
+ return ret;
}
static
-PMC* stub_vtable_repeat(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+PMC* stub_logical_not(PARROT_INTERP, PMC* pmc, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4540,18 +3500,18 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->repeat(interp, pmc, value, dest);
+ ret = orig_vtable->logical_not(interp, pmc, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "repeat"));
+ CONST_STRING(supervisor, "logical_not"));
return ret;
}
static
-PMC* stub_vtable_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+PMC* stub_concatenate(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -4562,543 +3522,560 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->repeat_int(interp, pmc, value, dest);
+ ret = orig_vtable->concatenate(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "repeat_int"));
+ CONST_STRING(supervisor, "concatenate"));
return ret;
}
static
-void stub_vtable_set_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx, PMC* value) {
+PMC* stub_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_attr_keyed(interp, pmc, key, idx, value);
+ ret = orig_vtable->concatenate_str(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_attr_keyed"));
+ CONST_STRING(supervisor, "concatenate_str"));
- return;
+ return ret;
}
static
-void stub_vtable_set_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx, PMC* value) {
+void stub_i_concatenate(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_attr_str(interp, pmc, idx, value);
+ orig_vtable->i_concatenate(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_attr_str"));
+ CONST_STRING(supervisor, "i_concatenate"));
return;
}
static
-void stub_vtable_set_bool(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_i_concatenate_str(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_bool(interp, pmc, value);
+ orig_vtable->i_concatenate_str(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_bool"));
+ CONST_STRING(supervisor, "i_concatenate_str"));
return;
}
static
-void stub_vtable_set_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, INTVAL value) {
+PMC* stub_repeat(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_integer_keyed(interp, pmc, key, value);
+ ret = orig_vtable->repeat(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_integer_keyed"));
+ CONST_STRING(supervisor, "repeat"));
- return;
+ return ret;
}
static
-void stub_vtable_set_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, INTVAL value) {
+PMC* stub_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_integer_keyed_int(interp, pmc, key, value);
+ ret = orig_vtable->repeat_int(interp, pmc, value, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_integer_keyed_int"));
+ CONST_STRING(supervisor, "repeat_int"));
- return;
+ return ret;
}
static
-void stub_vtable_set_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, INTVAL value) {
+void stub_i_repeat(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_integer_keyed_str(interp, pmc, key, value);
+ orig_vtable->i_repeat(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_integer_keyed_str"));
+ CONST_STRING(supervisor, "i_repeat"));
return;
}
static
-void stub_vtable_set_integer_native(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_i_repeat_int(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_integer_native(interp, pmc, value);
+ orig_vtable->i_repeat_int(interp, pmc, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_integer_native"));
+ CONST_STRING(supervisor, "i_repeat_int"));
return;
}
static
-void stub_vtable_set_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key, FLOATVAL value) {
+void stub_substr(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length, PMC* dest) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_number_keyed(interp, pmc, key, value);
+ orig_vtable->substr(interp, pmc, offset, length, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_number_keyed"));
+ CONST_STRING(supervisor, "substr"));
return;
}
static
-void stub_vtable_set_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, FLOATVAL value) {
+STRING* stub_substr_str(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_number_keyed_int(interp, pmc, key, value);
+ ret = orig_vtable->substr_str(interp, pmc, offset, length);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_number_keyed_int"));
+ CONST_STRING(supervisor, "substr_str"));
- return;
+ return ret;
}
static
-void stub_vtable_set_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, FLOATVAL value) {
+INTVAL stub_exists_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_number_keyed_str(interp, pmc, key, value);
+ ret = orig_vtable->exists_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_number_keyed_str"));
+ CONST_STRING(supervisor, "exists_keyed"));
- return;
+ return ret;
}
static
-void stub_vtable_set_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+INTVAL stub_exists_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_number_native(interp, pmc, value);
+ ret = orig_vtable->exists_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_number_native"));
+ CONST_STRING(supervisor, "exists_keyed_int"));
- return;
+ return ret;
}
static
-void stub_vtable_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+INTVAL stub_exists_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pmc(interp, pmc, value);
+ ret = orig_vtable->exists_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pmc"));
+ CONST_STRING(supervisor, "exists_keyed_str"));
- return;
+ return ret;
}
static
-void stub_vtable_set_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key, PMC* value) {
+INTVAL stub_defined_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pmc_keyed(interp, pmc, key, value);
+ ret = orig_vtable->defined_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pmc_keyed"));
+ CONST_STRING(supervisor, "defined_keyed"));
- return;
+ return ret;
}
static
-void stub_vtable_set_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, PMC* value) {
+INTVAL stub_defined_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pmc_keyed_int(interp, pmc, key, value);
+ ret = orig_vtable->defined_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pmc_keyed_int"));
+ CONST_STRING(supervisor, "defined_keyed_int"));
- return;
+ return ret;
}
static
-void stub_vtable_set_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
+INTVAL stub_defined_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pmc_keyed_str(interp, pmc, key, value);
+ ret = orig_vtable->defined_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pmc_keyed_str"));
+ CONST_STRING(supervisor, "defined_keyed_str"));
- return;
+ return ret;
}
static
-void stub_vtable_set_pointer(PARROT_INTERP, PMC* pmc, void* value) {
+void stub_delete_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pointer(interp, pmc, value);
+ orig_vtable->delete_keyed(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pointer"));
+ CONST_STRING(supervisor, "delete_keyed"));
return;
}
static
-void stub_vtable_set_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, void* value) {
+void stub_delete_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pointer_keyed(interp, pmc, key, value);
+ orig_vtable->delete_keyed_int(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pointer_keyed"));
+ CONST_STRING(supervisor, "delete_keyed_int"));
return;
}
static
-void stub_vtable_set_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, void* value) {
+void stub_delete_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pointer_keyed_int(interp, pmc, key, value);
+ orig_vtable->delete_keyed_str(interp, pmc, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pointer_keyed_int"));
+ CONST_STRING(supervisor, "delete_keyed_str"));
return;
}
static
-void stub_vtable_set_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, void* value) {
+opcode_t* stub_invoke(PARROT_INTERP, PMC* pmc, void* next) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ opcode_t* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_pointer_keyed_str(interp, pmc, key, value);
+ ret = orig_vtable->invoke(interp, pmc, next);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_pointer_keyed_str"));
+ CONST_STRING(supervisor, "invoke"));
- return;
+ return ret;
}
static
-void stub_vtable_set_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* value) {
+INTVAL stub_can(PARROT_INTERP, PMC* pmc, STRING* method) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_string_keyed(interp, pmc, key, value);
+ ret = orig_vtable->can(interp, pmc, method);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_string_keyed"));
+ CONST_STRING(supervisor, "can"));
- return;
+ return ret;
}
static
-void stub_vtable_set_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, STRING* value) {
+INTVAL stub_does_pmc(PARROT_INTERP, PMC* pmc, PMC* role) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_string_keyed_int(interp, pmc, key, value);
+ ret = orig_vtable->does_pmc(interp, pmc, role);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_string_keyed_int"));
+ CONST_STRING(supervisor, "does_pmc"));
- return;
+ return ret;
}
static
-void stub_vtable_set_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, STRING* value) {
+INTVAL stub_does(PARROT_INTERP, PMC* pmc, STRING* role) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_string_keyed_str(interp, pmc, key, value);
+ ret = orig_vtable->does(interp, pmc, role);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_string_keyed_str"));
+ CONST_STRING(supervisor, "does"));
- return;
+ return ret;
}
static
-void stub_vtable_set_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
+INTVAL stub_isa_pmc(PARROT_INTERP, PMC* pmc, PMC* _class) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->set_string_native(interp, pmc, value);
+ ret = orig_vtable->isa_pmc(interp, pmc, _class);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "set_string_native"));
+ CONST_STRING(supervisor, "isa_pmc"));
- return;
+ return ret;
}
static
-void stub_vtable_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
+INTVAL stub_isa(PARROT_INTERP, PMC* pmc, STRING* _class) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->setprop(interp, pmc, key, value);
+ ret = orig_vtable->isa(interp, pmc, _class);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "setprop"));
+ CONST_STRING(supervisor, "isa"));
- return;
+ return ret;
}
static
-void stub_vtable_share(PARROT_INTERP, PMC* pmc) {
+PMC* stub_get_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->share(interp, pmc);
+ ret = orig_vtable->get_attr_str(interp, pmc, idx);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "share"));
+ CONST_STRING(supervisor, "get_attr_str"));
- return;
+ return ret;
}
static
-PMC* stub_vtable_share_ro(PARROT_INTERP, PMC* pmc) {
+PMC* stub_get_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
@@ -5109,402 +4086,396 @@
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->share_ro(interp, pmc);
+ ret = orig_vtable->get_attr_keyed(interp, pmc, key, idx);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "share_ro"));
+ CONST_STRING(supervisor, "get_attr_keyed"));
return ret;
}
static
-FLOATVAL stub_vtable_shift_float(PARROT_INTERP, PMC* pmc) {
+void stub_set_attr_str(PARROT_INTERP, PMC* pmc, STRING* idx, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- FLOATVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->shift_float(interp, pmc);
+ orig_vtable->set_attr_str(interp, pmc, idx, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "shift_float"));
+ CONST_STRING(supervisor, "set_attr_str"));
- return ret;
+ return;
}
static
-INTVAL stub_vtable_shift_integer(PARROT_INTERP, PMC* pmc) {
+void stub_set_attr_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* idx, PMC* value) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->shift_integer(interp, pmc);
+ orig_vtable->set_attr_keyed(interp, pmc, key, idx, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "shift_integer"));
+ CONST_STRING(supervisor, "set_attr_keyed"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_shift_pmc(PARROT_INTERP, PMC* pmc) {
+void stub_add_parent(PARROT_INTERP, PMC* pmc, PMC* parent) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->shift_pmc(interp, pmc);
+ orig_vtable->add_parent(interp, pmc, parent);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "shift_pmc"));
+ CONST_STRING(supervisor, "add_parent"));
- return ret;
+ return;
}
static
-STRING* stub_vtable_shift_string(PARROT_INTERP, PMC* pmc) {
+void stub_remove_parent(PARROT_INTERP, PMC* pmc, PMC* parent) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- STRING* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->shift_string(interp, pmc);
+ orig_vtable->remove_parent(interp, pmc, parent);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "shift_string"));
+ CONST_STRING(supervisor, "remove_parent"));
- return ret;
+ return;
}
static
-void stub_vtable_splice(PARROT_INTERP, PMC* pmc, PMC* value, INTVAL offset, INTVAL count) {
+void stub_add_role(PARROT_INTERP, PMC* pmc, PMC* role) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->splice(interp, pmc, value, offset, count);
+ orig_vtable->add_role(interp, pmc, role);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "splice"));
+ CONST_STRING(supervisor, "add_role"));
return;
}
static
-void stub_vtable_substr(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length, PMC* dest) {
+void stub_remove_role(PARROT_INTERP, PMC* pmc, PMC* role) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->substr(interp, pmc, offset, length, dest);
+ orig_vtable->remove_role(interp, pmc, role);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "substr"));
+ CONST_STRING(supervisor, "remove_role"));
return;
}
static
-STRING* stub_vtable_substr_str(PARROT_INTERP, PMC* pmc, INTVAL offset, INTVAL length) {
+void stub_add_attribute(PARROT_INTERP, PMC* pmc, STRING* name, PMC* type) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- STRING* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->substr_str(interp, pmc, offset, length);
+ orig_vtable->add_attribute(interp, pmc, name, type);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "substr_str"));
+ CONST_STRING(supervisor, "add_attribute"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_subtract(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
+void stub_remove_attribute(PARROT_INTERP, PMC* pmc, STRING* name) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->subtract(interp, pmc, value, dest);
+ orig_vtable->remove_attribute(interp, pmc, name);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "subtract"));
+ CONST_STRING(supervisor, "remove_attribute"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_subtract_float(PARROT_INTERP, PMC* pmc, FLOATVAL value, PMC* dest) {
+void stub_add_method(PARROT_INTERP, PMC* pmc, STRING* method_name, PMC* sub_pmc) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->subtract_float(interp, pmc, value, dest);
+ orig_vtable->add_method(interp, pmc, method_name, sub_pmc);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "subtract_float"));
+ CONST_STRING(supervisor, "add_method"));
- return ret;
+ return;
}
static
-PMC* stub_vtable_subtract_int(PARROT_INTERP, PMC* pmc, INTVAL value, PMC* dest) {
+void stub_remove_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- PMC* ret;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->subtract_int(interp, pmc, value, dest);
+ orig_vtable->remove_method(interp, pmc, method_name);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "subtract_int"));
+ CONST_STRING(supervisor, "remove_method"));
- return ret;
+ return;
}
static
-void stub_vtable_thaw(PARROT_INTERP, PMC* pmc, PMC* info) {
+void stub_add_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name, PMC* sub_pmc) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->thaw(interp, pmc, info);
+ orig_vtable->add_vtable_override(interp, pmc, vtable_name, sub_pmc);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "thaw"));
+ CONST_STRING(supervisor, "add_vtable_override"));
return;
}
static
-void stub_vtable_thawfinish(PARROT_INTERP, PMC* pmc, PMC* info) {
+void stub_remove_vtable_override(PARROT_INTERP, PMC* pmc, STRING* vtable_name) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->thawfinish(interp, pmc, info);
+ orig_vtable->remove_vtable_override(interp, pmc, vtable_name);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "thawfinish"));
+ CONST_STRING(supervisor, "remove_vtable_override"));
return;
}
static
-INTVAL stub_vtable_type(PARROT_INTERP, PMC* pmc) {
+PMC* stub_inspect_str(PARROT_INTERP, PMC* pmc, STRING* what) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = orig_vtable->type(interp, pmc);
+ ret = orig_vtable->inspect_str(interp, pmc, what);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "type"));
+ CONST_STRING(supervisor, "inspect_str"));
return ret;
}
static
-void stub_vtable_unshift_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_freeze(PARROT_INTERP, PMC* pmc, PMC* info) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->unshift_float(interp, pmc, value);
+ orig_vtable->freeze(interp, pmc, info);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "unshift_float"));
+ CONST_STRING(supervisor, "freeze"));
return;
}
static
-void stub_vtable_unshift_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_thaw(PARROT_INTERP, PMC* pmc, PMC* info) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->unshift_integer(interp, pmc, value);
+ orig_vtable->thaw(interp, pmc, info);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "unshift_integer"));
+ CONST_STRING(supervisor, "thaw"));
return;
}
static
-void stub_vtable_unshift_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+void stub_thawfinish(PARROT_INTERP, PMC* pmc, PMC* info) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->unshift_pmc(interp, pmc, value);
+ orig_vtable->thawfinish(interp, pmc, info);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "unshift_pmc"));
+ CONST_STRING(supervisor, "thawfinish"));
return;
}
static
-void stub_vtable_unshift_string(PARROT_INTERP, PMC* pmc, STRING* value) {
+void stub_visit(PARROT_INTERP, PMC* pmc, PMC* info) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->unshift_string(interp, pmc, value);
+ orig_vtable->visit(interp, pmc, info);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "unshift_string"));
+ CONST_STRING(supervisor, "visit"));
return;
}
static
-void stub_vtable_visit(PARROT_INTERP, PMC* pmc, PMC* info) {
+void stub_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
-
+
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- orig_vtable->visit(interp, pmc, info);
+ orig_vtable->init_int(interp, pmc, initializer);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "visit"));
+ CONST_STRING(supervisor, "init_int"));
return;
}
+
+
/* END vtable stubs */
/*
@@ -5512,4 +4483,4 @@
* c-file-style: "parrot"
* End:
* vim: expandtab shiftwidth=4:
- */
+ */
\ No newline at end of file
Modified: branches/gsoc_instrument/src/vtable.tbl
==============================================================================
--- branches/gsoc_instrument/src/vtable.tbl Fri Jul 9 13:29:20 2010 (r48062)
+++ branches/gsoc_instrument/src/vtable.tbl Sat Jul 10 05:58:14 2010 (r48063)
@@ -274,9 +274,9 @@
PMC* inspect_str(STRING* what)
void freeze(PMC* info)
-void thaw (PMC* info) :write
-void thawfinish (PMC* info) :write
-void visit (PMC* info)
+void thaw(PMC* info) :write
+void thawfinish(PMC* info) :write
+void visit(PMC* info)
void share()
Added: branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sat Jul 10 05:58:14 2010 (r48063)
@@ -0,0 +1,234 @@
+#! perl
+# $Id$
+
+# Copyright (C) 2010, Parrot Foundation.
+
+=head1 NAME
+
+tools/build/gen_vtable_stubs.pl
+
+=head1 DESCRIPTION
+
+Generate VTable stubs for use in InstrumentVtable.
+
+Read the vtable entries from src/vtable.tbl and from
+there, generate the prototypes, stubs and groups and
+put the information in the appropriate placeholders in
+src/dynpmc/instrumentvtable.pmc.
+
+=head2 TODO
+
+-Add support for groups.
+
+=cut
+
+use warnings;
+use strict;
+
+use IO::File;
+use Fcntl qw(:DEFAULT :flock);
+
+my $dynpmc_file = 'src/dynpmc/instrumentvtable.pmc';
+my $vtable_file = 'src/vtable.tbl';
+
+my $dynpmc_fh = IO::File->new($dynpmc_file, O_RDWR | O_CREAT);
+my $vtable_fh = IO::File->new('src/vtable.tbl', O_RDWR | O_CREAT);
+
+die "Could not open $dynpmc_file!" if !$dynpmc_fh;
+die "Could not open $vtable_file!" if !$vtable_fh;
+
+flock($dynpmc_fh, LOCK_EX) or die "Cannot lock $dynpmc_file!";
+flock($vtable_fh, LOCK_EX) or die "Cannot lock $vtable_file!";
+
+my(%groups, @entries, @prototypes, @stubs);
+my $cur_group = 'CORE';
+while(<$vtable_fh>) {
+ # Remove whitespace and go on to the next line
+ # for comments and empty lines.
+ chomp;
+ if(m/^#/) { next; }
+ if(m/^\s*$/) { next; }
+
+ # Check for group change.
+ if(m/^\[(\w+)\]$/) {
+ $cur_group = $1;
+ next;
+ }
+
+ # Separate out the components.
+ # type name(params) annotations
+ if(m/^(.+)\s+(.+)\s*\((.+)\)\s*(.*)$/) {
+ # Generate the components.
+ my @data = ($1, $2, $3, $4);
+ #print "($1) ($2) ($3) ($4)\n";
+
+ # Prepend the first 2 parameters that all vtable entries will
+ # receive: PARROT_INTERP, PMC *pmc
+ $data[2] = ($data[2] eq '')
+ ? 'PARROT_INTERP, PMC* pmc'
+ : 'PARROT_INTERP, PMC* pmc, '.$data[2];
+
+ push @prototypes, gen_prototype(@data);
+ push @stubs, gen_stub(@data);
+ push @entries, $data[1];
+
+ my $annotation;
+ foreach $annotation (split /\s+/, $data[3]) {
+ $annotation =~ s/://;
+ push @{$groups{$annotation}}, $data[1];
+ }
+
+ push @{$groups{$cur_group}}, $data[1];
+ }
+}
+
+my %placeholders = (
+ 'vtable prototypes' => join('', @prototypes),
+ 'vtable stubs' => join('', @stubs),
+ 'vtable mappings' => gen_mapping_string(@entries)
+);
+
+my @contents = ();
+my($ignore, $matching_string) = (0, undef);
+while(<$dynpmc_fh>) {
+ chomp;
+
+ # If we are supposed to ignore, check for end of placeholder
+ # before ignoring.
+ if($ignore) {
+ if(m/^\s*\/\* END (.*) \*\/$/) {
+ if($1 eq $matching_string) {
+ push @contents, $_;
+ $ignore = 0;
+ }
+ }
+ next;
+ }
+
+ # Push into @contents and check if we have the beginnings of a placeholder.
+ push @contents, $_;
+ if(m/^\s*\/\* BEGIN (.*) \*\/$/) {
+ $matching_string = $1;
+ $ignore = 1;
+ push @contents, $placeholders{$matching_string};
+ }
+}
+
+flock($dynpmc_fh, LOCK_UN) or die "Cannot unlock $dynpmc_file!";
+flock($vtable_fh, LOCK_UN) or die "Cannot unlock $vtable_file!";
+
+$dynpmc_fh->close();
+$vtable_fh->close();
+
+# Write to the file.
+$dynpmc_fh = IO::File->new($dynpmc_file, O_WRONLY | O_CREAT | O_TRUNC)
+or die "Could not write to file $dynpmc_file!";
+
+flock($dynpmc_fh, LOCK_EX);
+print $dynpmc_fh join("\n", @contents);
+flock($dynpmc_fh, LOCK_UN);
+
+$dynpmc_fh->close();
+
+sub gen_prototype {
+ my($ret, $name, $params, $anno) = @_;
+
+ return <<PROTO;
+static $ret stub_$name($params);
+PROTO
+}
+
+sub gen_stub {
+ my($ret, $name, $params, $anno) = @_;
+
+ # Process the parameter list.
+ my @param_types = ();
+ my @param_names = ();
+ my $param;
+ foreach $param (split /\s*,\s*/, $params) {
+ chomp $param;
+
+ if($param eq '') { next; }
+
+ if($param eq 'PARROT_INTERP') {
+ push @param_types, 'Parrot_Interp';
+ push @param_names, 'interp';
+ next;
+ }
+
+ my @tokens = split(/\s+/, $param);
+ push @param_types, $tokens[0];
+ push @param_names, $tokens[1];
+ }
+
+ my $param_list_flat = (scalar(@param_names)) ? join(', ', @param_names) : '';
+
+ my($ret_dec, $ret_ret, $ret_last) = ('','','');
+ if ($ret ne 'void') {
+ $ret_dec = $ret.' ret;'."\n";
+ $ret_ret = ' ret =';
+ $ret_last = ' ret';
+ }
+
+ return <<CODE;
+static
+$ret stub_$name($params) {
+ PMC *instr_vt, *data;
+ _vtable *orig_vtable;
+ Parrot_Interp supervisor;
+ $ret_dec
+ instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_vtable(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ $ret_ret orig_vtable->$name($param_list_flat);
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "$name"));
+
+ return$ret_last;
+}
+
+CODE
+}
+
+sub gen_mapping_string {
+ my @entries = @_;
+
+ my($name, @orig, @instr, @stubs);
+ foreach $name (@entries) {
+ my $orig = <<OFFSET;
+ parrot_hash_put(interp, orig, CONST_STRING(interp, "$name"),
+ orig_vtable->$name);
+OFFSET
+ push @orig, $orig;
+
+ my $instr = <<INSTR;
+ parrot_hash_put(interp, instr, CONST_STRING(interp, "$name"),
+ &(instr_vtable->$name));
+INSTR
+ push @instr, $instr;
+
+ my $stub_entry = <<STUB_ENTRY;
+ parrot_hash_put(interp, stub, CONST_STRING(interp, "$name"),
+ stub_$name);
+STUB_ENTRY
+ push @stubs, $stub_entry;
+ }
+
+ return <<MAPPINGS;
+ /* Build mappings for name -> original function.vtable entry */
+ at orig
+
+ /* Build mappings for name -> instrumented function.vtable entry. */
+ at instr
+
+ /* Build mappings for name -> stub_function if it wasn't done already. */
+ if (parrot_hash_size(interp, stub) == 0) {
+ at stubs
+ }
+MAPPINGS
+}
More information about the parrot-commits
mailing list