[svn:parrot] r48101 - in branches/gsoc_instrument: src/dynpmc tools/build
khairul at svn.parrot.org
khairul at svn.parrot.org
Sat Jul 17 13:32:21 UTC 2010
Author: khairul
Date: Sat Jul 17 13:32:21 2010
New Revision: 48101
URL: https://trac.parrot.org/parrot/changeset/48101
Log:
Regenerated code to add size hash entry for gc allocations + all group
Modified:
branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
branches/gsoc_instrument/tools/build/gen_gc_stubs.pl
branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
Modified: branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Fri Jul 16 17:46:16 2010 (r48100)
+++ branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Sat Jul 17 13:32:21 2010 (r48101)
@@ -403,6 +403,71 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "finalize_gc_system"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "destroy_child_interp"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "do_gc_mark"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "compact_string_pool"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "mark_special"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pmc_needs_early_collection"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "init_pool"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_pmc_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_pmc_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_string_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_string_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_bufferlike_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_bufferlike_header"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_pmc_attributes"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_pmc_attributes"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_string_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "reallocate_string_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_buffer_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "reallocate_buffer_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_fixed_size_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_fixed_size_storage"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_memory_chunk"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "reallocate_memory_chunk"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "free_memory_chunk"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "block_mark"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unblock_mark"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "block_sweep"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unblock_sweep"));
+ parrot_hash_put(interp, gc_group_items,
+ CONST_STRING(interp, "all"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "reallocate_string_storage"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "reallocate_buffer_storage"));
@@ -1013,6 +1078,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ sizeof (PMC));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1070,6 +1141,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ sizeof (STRING));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1127,6 +1204,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ sizeof (Buffer));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1187,6 +1270,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ VTABLE_get_pmc_keyed_int(supervisor, params, 0)->vtable->attr_size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1246,6 +1335,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1277,6 +1372,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
@@ -1308,6 +1409,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ nsize);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1339,6 +1446,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ newsize);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
@@ -1368,6 +1481,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1428,6 +1547,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1460,6 +1585,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ newsize);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
@@ -1489,6 +1620,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ size);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
@@ -1525,6 +1662,12 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ newsize);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
Modified: branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Fri Jul 16 17:46:16 2010 (r48100)
+++ branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Sat Jul 17 13:32:21 2010 (r48101)
@@ -180,26 +180,41 @@
/* BELOW LIES GENERATED CODE GENERATED BY tools/build/gen_vtable_stubs.pl */
/* Stub Prototypes */
/* BEGIN vtable prototypes */
+static void stub_init(PARROT_INTERP, PMC* pmc);
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 void stub_mark(PARROT_INTERP, PMC* pmc);
+static void stub_destroy(PARROT_INTERP, PMC* pmc);
+static PMC* stub_get_namespace(PARROT_INTERP, PMC* pmc);
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_getprops(PARROT_INTERP, PMC* pmc);
+static INTVAL stub_type(PARROT_INTERP, PMC* pmc);
+static STRING* stub_name(PARROT_INTERP, PMC* pmc);
+static PMC* stub_clone(PARROT_INTERP, PMC* pmc);
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(PARROT_INTERP, PMC* pmc);
static INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
+static FLOATVAL stub_get_number(PARROT_INTERP, PMC* pmc);
static FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
+static STRING* stub_get_string(PARROT_INTERP, PMC* pmc);
+static STRING* stub_get_repr(PARROT_INTERP, PMC* pmc);
static STRING* stub_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
+static INTVAL stub_get_bool(PARROT_INTERP, PMC* pmc);
+static PMC* stub_get_pmc(PARROT_INTERP, PMC* pmc);
static PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
+static void* stub_get_pointer(PARROT_INTERP, PMC* pmc);
static void* stub_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
@@ -226,10 +241,19 @@
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 INTVAL stub_elements(PARROT_INTERP, PMC* pmc);
+static INTVAL stub_pop_integer(PARROT_INTERP, PMC* pmc);
+static FLOATVAL stub_pop_float(PARROT_INTERP, PMC* pmc);
+static STRING* stub_pop_string(PARROT_INTERP, PMC* pmc);
+static PMC* stub_pop_pmc(PARROT_INTERP, PMC* pmc);
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 INTVAL stub_shift_integer(PARROT_INTERP, PMC* pmc);
+static FLOATVAL stub_shift_float(PARROT_INTERP, PMC* pmc);
+static STRING* stub_shift_string(PARROT_INTERP, PMC* pmc);
+static PMC* stub_shift_pmc(PARROT_INTERP, PMC* pmc);
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);
@@ -271,8 +295,12 @@
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 void stub_increment(PARROT_INTERP, PMC* pmc);
+static void stub_decrement(PARROT_INTERP, PMC* pmc);
static PMC* stub_absolute(PARROT_INTERP, PMC* pmc, PMC* dest);
+static void stub_i_absolute(PARROT_INTERP, PMC* pmc);
static PMC* stub_neg(PARROT_INTERP, PMC* pmc, PMC* dest);
+static void stub_i_neg(PARROT_INTERP, PMC* pmc);
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);
@@ -285,6 +313,7 @@
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 void stub_i_logical_not(PARROT_INTERP, PMC* pmc);
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);
@@ -298,12 +327,15 @@
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(PARROT_INTERP, PMC* pmc);
static INTVAL stub_defined_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static INTVAL stub_defined_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static INTVAL stub_defined_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
static void stub_delete_keyed(PARROT_INTERP, PMC* pmc, PMC* key);
static void stub_delete_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key);
static void stub_delete_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key);
+static PMC* stub_get_iter(PARROT_INTERP, PMC* pmc);
+static INTVAL stub_hashvalue(PARROT_INTERP, PMC* pmc);
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);
@@ -314,6 +346,7 @@
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 PMC* stub_get_class(PARROT_INTERP, PMC* pmc);
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);
@@ -324,11 +357,14 @@
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(PARROT_INTERP, PMC* pmc);
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_share(PARROT_INTERP, PMC* pmc);
+static PMC* stub_share_ro(PARROT_INTERP, PMC* pmc);
static void stub_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer);
/* END vtable prototypes */
@@ -344,6 +380,9 @@
/* BEGIN vtable mapping name stubs */
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "init"),
+ stub_init);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "init_pmc"),
stub_init_pmc);
parrot_hash_put(interp, vtable_name_stubs,
@@ -353,6 +392,15 @@
CONST_STRING(interp, "morph"),
stub_morph);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "mark"),
+ stub_mark);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "destroy"),
+ stub_destroy);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_namespace"),
+ stub_get_namespace);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "getprop"),
stub_getprop);
parrot_hash_put(interp, vtable_name_stubs,
@@ -362,12 +410,27 @@
CONST_STRING(interp, "delprop"),
stub_delprop);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "getprops"),
+ stub_getprops);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "type"),
+ stub_type);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "name"),
+ stub_name);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "clone"),
+ stub_clone);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "clone_pmc"),
stub_clone_pmc);
parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "find_method"),
stub_find_method);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_integer"),
+ stub_get_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "get_integer_keyed"),
stub_get_integer_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -377,6 +440,9 @@
CONST_STRING(interp, "get_integer_keyed_str"),
stub_get_integer_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_number"),
+ stub_get_number);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "get_number_keyed"),
stub_get_number_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -386,6 +452,12 @@
CONST_STRING(interp, "get_number_keyed_str"),
stub_get_number_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_string"),
+ stub_get_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_repr"),
+ stub_get_repr);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "get_string_keyed"),
stub_get_string_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -395,6 +467,12 @@
CONST_STRING(interp, "get_string_keyed_str"),
stub_get_string_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_bool"),
+ stub_get_bool);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pmc"),
+ stub_get_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "get_pmc_keyed"),
stub_get_pmc_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -404,6 +482,9 @@
CONST_STRING(interp, "get_pmc_keyed_str"),
stub_get_pmc_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_pointer"),
+ stub_get_pointer);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "get_pointer_keyed"),
stub_get_pointer_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -482,6 +563,21 @@
CONST_STRING(interp, "set_pointer_keyed_str"),
stub_set_pointer_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "elements"),
+ stub_elements);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_integer"),
+ stub_pop_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_float"),
+ stub_pop_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_string"),
+ stub_pop_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "pop_pmc"),
+ stub_pop_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "push_integer"),
stub_push_integer);
parrot_hash_put(interp, vtable_name_stubs,
@@ -494,6 +590,18 @@
CONST_STRING(interp, "push_pmc"),
stub_push_pmc);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_integer"),
+ stub_shift_integer);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_float"),
+ stub_shift_float);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_string"),
+ stub_shift_string);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "shift_pmc"),
+ stub_shift_pmc);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "unshift_integer"),
stub_unshift_integer);
parrot_hash_put(interp, vtable_name_stubs,
@@ -617,12 +725,24 @@
CONST_STRING(interp, "i_modulus_float"),
stub_i_modulus_float);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "increment"),
+ stub_increment);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "decrement"),
+ stub_decrement);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "absolute"),
stub_absolute);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_absolute"),
+ stub_i_absolute);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "neg"),
stub_neg);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_neg"),
+ stub_i_neg);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "is_equal"),
stub_is_equal);
parrot_hash_put(interp, vtable_name_stubs,
@@ -659,6 +779,9 @@
CONST_STRING(interp, "logical_not"),
stub_logical_not);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "i_logical_not"),
+ stub_i_logical_not);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "concatenate"),
stub_concatenate);
parrot_hash_put(interp, vtable_name_stubs,
@@ -698,6 +821,9 @@
CONST_STRING(interp, "exists_keyed_str"),
stub_exists_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "defined"),
+ stub_defined);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "defined_keyed"),
stub_defined_keyed);
parrot_hash_put(interp, vtable_name_stubs,
@@ -716,6 +842,12 @@
CONST_STRING(interp, "delete_keyed_str"),
stub_delete_keyed_str);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_iter"),
+ stub_get_iter);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "hashvalue"),
+ stub_hashvalue);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "invoke"),
stub_invoke);
parrot_hash_put(interp, vtable_name_stubs,
@@ -746,6 +878,9 @@
CONST_STRING(interp, "set_attr_keyed"),
stub_set_attr_keyed);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "get_class"),
+ stub_get_class);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "add_parent"),
stub_add_parent);
parrot_hash_put(interp, vtable_name_stubs,
@@ -776,6 +911,9 @@
CONST_STRING(interp, "remove_vtable_override"),
stub_remove_vtable_override);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "inspect"),
+ stub_inspect);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "inspect_str"),
stub_inspect_str);
parrot_hash_put(interp, vtable_name_stubs,
@@ -791,6 +929,12 @@
CONST_STRING(interp, "visit"),
stub_visit);
parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "share"),
+ stub_share);
+ parrot_hash_put(interp, vtable_name_stubs,
+ CONST_STRING(interp, "share_ro"),
+ stub_share_ro);
+ parrot_hash_put(interp, vtable_name_stubs,
CONST_STRING(interp, "init_int"),
stub_init_int);
/* END vtable mapping name stubs */
@@ -809,30 +953,44 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_integer"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_integer_keyed"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_integer_keyed_int"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_integer_keyed_str"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_number"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_number_keyed"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_number_keyed_int"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_number_keyed_str"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_repr"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_string_keyed"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_string_keyed_int"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_string_keyed_str"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_bool"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pmc"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_pmc_keyed"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_pmc_keyed_int"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_pmc_keyed_str"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pointer"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_pointer_keyed"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "get_pointer_keyed_int"));
@@ -890,30 +1048,163 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "concatenate"));
+ CONST_STRING(interp, "init"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "concatenate_str"));
+ CONST_STRING(interp, "init_pmc"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "i_concatenate"));
+ CONST_STRING(interp, "instantiate"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "i_concatenate_str"));
+ CONST_STRING(interp, "morph"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "repeat"));
+ CONST_STRING(interp, "mark"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "repeat_int"));
+ CONST_STRING(interp, "destroy"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "i_repeat"));
+ CONST_STRING(interp, "get_namespace"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "i_repeat_int"));
+ CONST_STRING(interp, "getprop"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "substr"));
+ CONST_STRING(interp, "setprop"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "substr_str"));
- parrot_hash_put(interp, vtable_group_items,
- CONST_STRING(interp, "string"),
- temp);
-
- temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ CONST_STRING(interp, "delprop"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "getprops"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "type"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "name"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "clone"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "clone_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "find_method"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_integer_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_integer_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_integer_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_number"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_number_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_number_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_number_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_repr"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_string_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_string_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_string_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_bool"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pmc_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pointer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pointer_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_integer_native"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_integer_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_integer_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_integer_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_number_native"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_number_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_number_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_number_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_string_native"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "assign_string_native"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_string_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_string_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_string_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_bool"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "assign_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pmc_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pmc_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pmc_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pointer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pointer_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pointer_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_pointer_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "elements"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unshift_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unshift_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unshift_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "unshift_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "splice"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "add"));
VTABLE_push_string(interp, temp,
@@ -987,14 +1278,71 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "i_modulus_float"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "increment"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "decrement"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "absolute"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_absolute"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "neg"));
- parrot_hash_put(interp, vtable_group_items,
- CONST_STRING(interp, "math"),
- temp);
-
- temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_neg"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "is_equal"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "is_equal_num"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "is_equal_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "is_same"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "cmp"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "cmp_num"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "cmp_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "cmp_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "logical_or"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "logical_and"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "logical_xor"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "logical_not"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_logical_not"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "concatenate"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "concatenate_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_concatenate"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_concatenate_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "repeat"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "repeat_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_repeat"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_repeat_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "substr"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "substr_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "exists_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "exists_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "exists_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "defined"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "defined_keyed"));
VTABLE_push_string(interp, temp,
@@ -1008,6 +1356,10 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "delete_keyed_str"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_iter"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "hashvalue"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "invoke"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "can"));
@@ -1028,6 +1380,8 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "set_attr_keyed"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_class"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "add_parent"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "remove_parent"));
@@ -1048,6 +1402,8 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "remove_vtable_override"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "inspect"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "inspect_str"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "freeze"));
@@ -1058,21 +1414,240 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "visit"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "share"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "share_ro"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "init_int"));
parrot_hash_put(interp, vtable_group_items,
- CONST_STRING(interp, "main"),
+ CONST_STRING(interp, "all"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "push_integer"));
+ CONST_STRING(interp, "concatenate"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "push_float"));
+ CONST_STRING(interp, "concatenate_str"));
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "push_string"));
+ CONST_STRING(interp, "i_concatenate"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_concatenate_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "repeat"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "repeat_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_repeat"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_repeat_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "substr"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "substr_str"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "string"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "defined"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "defined_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "defined_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "defined_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "delete_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "delete_keyed_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "delete_keyed_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_iter"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "hashvalue"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "invoke"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "can"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "does_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "does"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "isa_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "isa"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_attr_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_attr_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_attr_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "set_attr_keyed"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_class"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_parent"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "remove_parent"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_role"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "remove_role"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_attribute"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "remove_attribute"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_method"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "remove_method"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_vtable_override"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "remove_vtable_override"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "inspect"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "inspect_str"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "freeze"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "thaw"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "thawfinish"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "visit"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "share"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "share_ro"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "init_int"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "main"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "add_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_add"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_add_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_add_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "subtract"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "subtract_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "subtract_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_subtract"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_subtract_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_subtract_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "multiply"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "multiply_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "multiply_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_multiply"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_multiply_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_multiply_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "divide"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "divide_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "divide_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_divide"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_divide_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_divide_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "floor_divide"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "floor_divide_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "floor_divide_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_floor_divide"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_floor_divide_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_floor_divide_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "modulus"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "modulus_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "modulus_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_modulus"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_modulus_int"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_modulus_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "increment"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "decrement"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "absolute"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_absolute"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "neg"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_neg"));
+ parrot_hash_put(interp, vtable_group_items,
+ CONST_STRING(interp, "math"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "elements"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "pop_pmc"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "push_string"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "push_pmc"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_integer"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_float"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_string"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "shift_pmc"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "unshift_integer"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "unshift_float"));
@@ -1111,6 +1686,8 @@
CONST_STRING(interp, "logical_xor"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "logical_not"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_logical_not"));
parrot_hash_put(interp, vtable_group_items,
CONST_STRING(interp, "cmp"),
temp);
@@ -1155,6 +1732,16 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "i_modulus_float"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "increment"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "decrement"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_absolute"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_neg"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "i_logical_not"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "i_concatenate"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "i_concatenate_str"));
@@ -1196,18 +1783,34 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "init"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "init_pmc"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "instantiate"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "morph"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "mark"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "destroy"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "get_namespace"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "getprop"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "setprop"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "delprop"));
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "getprops"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "type"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "name"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "clone"));
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "clone_pmc"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "find_method"));
@@ -1221,6 +1824,13 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "init"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "core"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "init_pmc"),
temp);
@@ -1244,126 +1854,224 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "getprop"),
+ CONST_STRING(interp, "mark"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "setprop"),
+ CONST_STRING(interp, "destroy"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "delprop"),
+ CONST_STRING(interp, "get_namespace"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "clone_pmc"),
+ CONST_STRING(interp, "getprop"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "find_method"),
+ CONST_STRING(interp, "setprop"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_integer_keyed"),
+ CONST_STRING(interp, "delprop"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_integer_keyed_int"),
+ CONST_STRING(interp, "getprops"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_integer_keyed_str"),
+ CONST_STRING(interp, "type"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_number_keyed"),
+ CONST_STRING(interp, "name"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_number_keyed_int"),
+ CONST_STRING(interp, "clone"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_number_keyed_str"),
+ CONST_STRING(interp, "clone_pmc"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
- CONST_STRING(interp, "fetch"));
+ CONST_STRING(interp, "core"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_string_keyed"),
+ CONST_STRING(interp, "find_method"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_string_keyed_int"),
+ CONST_STRING(interp, "get_integer"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_string_keyed_str"),
+ CONST_STRING(interp, "get_integer_keyed"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_pmc_keyed"),
+ CONST_STRING(interp, "get_integer_keyed_int"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_pmc_keyed_int"),
+ CONST_STRING(interp, "get_integer_keyed_str"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_pmc_keyed_str"),
+ CONST_STRING(interp, "get_number"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetch"));
parrot_hash_put(interp, vtable_item_groups,
- CONST_STRING(interp, "get_pointer_keyed"),
+ CONST_STRING(interp, "get_number_keyed"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_number_keyed_int"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_number_keyed_str"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_string"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_repr"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_string_keyed"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_string_keyed_int"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_string_keyed_str"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_bool"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pmc"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pmc_keyed"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pmc_keyed_int"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pmc_keyed_str"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pointer"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetch"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_pointer_keyed"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
@@ -1545,6 +2253,41 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetchsize"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "elements"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "pop_integer"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "pop_float"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "pop_string"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "pop_pmc"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "push_integer"),
temp);
@@ -1573,6 +2316,34 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "fetchsize"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "shift_integer"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "shift_float"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "shift_string"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "shift_pmc"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "fetchsize"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "unshift_integer"),
temp);
@@ -1895,6 +2666,24 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "math"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "write"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "increment"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "math"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "write"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "decrement"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "math"));
parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "absolute"),
temp);
@@ -1902,12 +2691,30 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "math"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "write"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "i_absolute"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "math"));
parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "neg"),
temp);
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "math"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "write"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "i_neg"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "cmp"));
parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "is_equal"),
@@ -1992,6 +2799,15 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "cmp"));
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "write"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "i_logical_not"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
CONST_STRING(interp, "string"));
parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "concatenate"),
@@ -2093,6 +2909,13 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "main"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "defined"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "defined_keyed"),
temp);
@@ -2135,6 +2958,20 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "main"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_iter"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "hashvalue"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "invoke"),
temp);
@@ -2208,6 +3045,13 @@
temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "get_class"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "write"));
parrot_hash_put(interp, vtable_item_groups,
@@ -2299,6 +3143,13 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "main"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "inspect"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "inspect_str"),
temp);
@@ -2338,6 +3189,20 @@
VTABLE_push_string(interp, temp,
CONST_STRING(interp, "main"));
parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "share"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
+ CONST_STRING(interp, "share_ro"),
+ temp);
+
+ temp = Parrot_pmc_new(interp, enum_class_ResizableStringArray);
+ VTABLE_push_string(interp, temp,
+ CONST_STRING(interp, "main"));
+ parrot_hash_put(interp, vtable_item_groups,
CONST_STRING(interp, "init_int"),
temp);
/* END vtable mapping item groups */
@@ -2358,6 +3223,9 @@
_vtable *vt_orig, _vtable *vt_instr) {
/* BEGIN vtable mapping name offset */
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "init"),
+ &(vt_instr->init));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "init_pmc"),
&(vt_instr->init_pmc));
parrot_hash_put(interp, instr_hash,
@@ -2367,6 +3235,15 @@
CONST_STRING(interp, "morph"),
&(vt_instr->morph));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "mark"),
+ &(vt_instr->mark));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "destroy"),
+ &(vt_instr->destroy));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_namespace"),
+ &(vt_instr->get_namespace));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "getprop"),
&(vt_instr->getprop));
parrot_hash_put(interp, instr_hash,
@@ -2376,12 +3253,27 @@
CONST_STRING(interp, "delprop"),
&(vt_instr->delprop));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "getprops"),
+ &(vt_instr->getprops));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "type"),
+ &(vt_instr->type));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "name"),
+ &(vt_instr->name));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "clone"),
+ &(vt_instr->clone));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "clone_pmc"),
&(vt_instr->clone_pmc));
parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "find_method"),
&(vt_instr->find_method));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_integer"),
+ &(vt_instr->get_integer));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "get_integer_keyed"),
&(vt_instr->get_integer_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2391,6 +3283,9 @@
CONST_STRING(interp, "get_integer_keyed_str"),
&(vt_instr->get_integer_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_number"),
+ &(vt_instr->get_number));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "get_number_keyed"),
&(vt_instr->get_number_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2400,6 +3295,12 @@
CONST_STRING(interp, "get_number_keyed_str"),
&(vt_instr->get_number_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_string"),
+ &(vt_instr->get_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_repr"),
+ &(vt_instr->get_repr));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "get_string_keyed"),
&(vt_instr->get_string_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2409,6 +3310,12 @@
CONST_STRING(interp, "get_string_keyed_str"),
&(vt_instr->get_string_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_bool"),
+ &(vt_instr->get_bool));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pmc"),
+ &(vt_instr->get_pmc));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "get_pmc_keyed"),
&(vt_instr->get_pmc_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2418,6 +3325,9 @@
CONST_STRING(interp, "get_pmc_keyed_str"),
&(vt_instr->get_pmc_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_pointer"),
+ &(vt_instr->get_pointer));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "get_pointer_keyed"),
&(vt_instr->get_pointer_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2496,6 +3406,21 @@
CONST_STRING(interp, "set_pointer_keyed_str"),
&(vt_instr->set_pointer_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "elements"),
+ &(vt_instr->elements));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_integer"),
+ &(vt_instr->pop_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_float"),
+ &(vt_instr->pop_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_string"),
+ &(vt_instr->pop_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pop_pmc"),
+ &(vt_instr->pop_pmc));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "push_integer"),
&(vt_instr->push_integer));
parrot_hash_put(interp, instr_hash,
@@ -2508,6 +3433,18 @@
CONST_STRING(interp, "push_pmc"),
&(vt_instr->push_pmc));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_integer"),
+ &(vt_instr->shift_integer));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_float"),
+ &(vt_instr->shift_float));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_string"),
+ &(vt_instr->shift_string));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "shift_pmc"),
+ &(vt_instr->shift_pmc));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "unshift_integer"),
&(vt_instr->unshift_integer));
parrot_hash_put(interp, instr_hash,
@@ -2631,12 +3568,24 @@
CONST_STRING(interp, "i_modulus_float"),
&(vt_instr->i_modulus_float));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "increment"),
+ &(vt_instr->increment));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "decrement"),
+ &(vt_instr->decrement));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "absolute"),
&(vt_instr->absolute));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_absolute"),
+ &(vt_instr->i_absolute));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "neg"),
&(vt_instr->neg));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_neg"),
+ &(vt_instr->i_neg));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "is_equal"),
&(vt_instr->is_equal));
parrot_hash_put(interp, instr_hash,
@@ -2673,6 +3622,9 @@
CONST_STRING(interp, "logical_not"),
&(vt_instr->logical_not));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "i_logical_not"),
+ &(vt_instr->i_logical_not));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "concatenate"),
&(vt_instr->concatenate));
parrot_hash_put(interp, instr_hash,
@@ -2712,6 +3664,9 @@
CONST_STRING(interp, "exists_keyed_str"),
&(vt_instr->exists_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "defined"),
+ &(vt_instr->defined));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "defined_keyed"),
&(vt_instr->defined_keyed));
parrot_hash_put(interp, instr_hash,
@@ -2730,6 +3685,12 @@
CONST_STRING(interp, "delete_keyed_str"),
&(vt_instr->delete_keyed_str));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_iter"),
+ &(vt_instr->get_iter));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "hashvalue"),
+ &(vt_instr->hashvalue));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "invoke"),
&(vt_instr->invoke));
parrot_hash_put(interp, instr_hash,
@@ -2760,6 +3721,9 @@
CONST_STRING(interp, "set_attr_keyed"),
&(vt_instr->set_attr_keyed));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "get_class"),
+ &(vt_instr->get_class));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "add_parent"),
&(vt_instr->add_parent));
parrot_hash_put(interp, instr_hash,
@@ -2790,6 +3754,9 @@
CONST_STRING(interp, "remove_vtable_override"),
&(vt_instr->remove_vtable_override));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "inspect"),
+ &(vt_instr->inspect));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "inspect_str"),
&(vt_instr->inspect_str));
parrot_hash_put(interp, instr_hash,
@@ -2805,12 +3772,21 @@
CONST_STRING(interp, "visit"),
&(vt_instr->visit));
parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "share"),
+ &(vt_instr->share));
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "share_ro"),
+ &(vt_instr->share_ro));
+ parrot_hash_put(interp, instr_hash,
CONST_STRING(interp, "init_int"),
&(vt_instr->init_int));
/* END vtable mapping name offset */
/* BEGIN vtable mapping name original */
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "init"),
+ vt_orig->init);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "init_pmc"),
vt_orig->init_pmc);
parrot_hash_put(interp, orig_hash,
@@ -2820,6 +3796,15 @@
CONST_STRING(interp, "morph"),
vt_orig->morph);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "mark"),
+ vt_orig->mark);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "destroy"),
+ vt_orig->destroy);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_namespace"),
+ vt_orig->get_namespace);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "getprop"),
vt_orig->getprop);
parrot_hash_put(interp, orig_hash,
@@ -2829,12 +3814,27 @@
CONST_STRING(interp, "delprop"),
vt_orig->delprop);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "getprops"),
+ vt_orig->getprops);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "type"),
+ vt_orig->type);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "name"),
+ vt_orig->name);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "clone"),
+ vt_orig->clone);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "clone_pmc"),
vt_orig->clone_pmc);
parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "find_method"),
vt_orig->find_method);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_integer"),
+ vt_orig->get_integer);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "get_integer_keyed"),
vt_orig->get_integer_keyed);
parrot_hash_put(interp, orig_hash,
@@ -2844,6 +3844,9 @@
CONST_STRING(interp, "get_integer_keyed_str"),
vt_orig->get_integer_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_number"),
+ vt_orig->get_number);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "get_number_keyed"),
vt_orig->get_number_keyed);
parrot_hash_put(interp, orig_hash,
@@ -2853,6 +3856,12 @@
CONST_STRING(interp, "get_number_keyed_str"),
vt_orig->get_number_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_string"),
+ vt_orig->get_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_repr"),
+ vt_orig->get_repr);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "get_string_keyed"),
vt_orig->get_string_keyed);
parrot_hash_put(interp, orig_hash,
@@ -2862,6 +3871,12 @@
CONST_STRING(interp, "get_string_keyed_str"),
vt_orig->get_string_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_bool"),
+ vt_orig->get_bool);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pmc"),
+ vt_orig->get_pmc);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "get_pmc_keyed"),
vt_orig->get_pmc_keyed);
parrot_hash_put(interp, orig_hash,
@@ -2871,6 +3886,9 @@
CONST_STRING(interp, "get_pmc_keyed_str"),
vt_orig->get_pmc_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_pointer"),
+ vt_orig->get_pointer);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "get_pointer_keyed"),
vt_orig->get_pointer_keyed);
parrot_hash_put(interp, orig_hash,
@@ -2949,6 +3967,21 @@
CONST_STRING(interp, "set_pointer_keyed_str"),
vt_orig->set_pointer_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "elements"),
+ vt_orig->elements);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_integer"),
+ vt_orig->pop_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_float"),
+ vt_orig->pop_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_string"),
+ vt_orig->pop_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pop_pmc"),
+ vt_orig->pop_pmc);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "push_integer"),
vt_orig->push_integer);
parrot_hash_put(interp, orig_hash,
@@ -2961,6 +3994,18 @@
CONST_STRING(interp, "push_pmc"),
vt_orig->push_pmc);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_integer"),
+ vt_orig->shift_integer);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_float"),
+ vt_orig->shift_float);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_string"),
+ vt_orig->shift_string);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "shift_pmc"),
+ vt_orig->shift_pmc);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "unshift_integer"),
vt_orig->unshift_integer);
parrot_hash_put(interp, orig_hash,
@@ -3084,12 +4129,24 @@
CONST_STRING(interp, "i_modulus_float"),
vt_orig->i_modulus_float);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "increment"),
+ vt_orig->increment);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "decrement"),
+ vt_orig->decrement);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "absolute"),
vt_orig->absolute);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_absolute"),
+ vt_orig->i_absolute);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "neg"),
vt_orig->neg);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_neg"),
+ vt_orig->i_neg);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "is_equal"),
vt_orig->is_equal);
parrot_hash_put(interp, orig_hash,
@@ -3126,6 +4183,9 @@
CONST_STRING(interp, "logical_not"),
vt_orig->logical_not);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "i_logical_not"),
+ vt_orig->i_logical_not);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "concatenate"),
vt_orig->concatenate);
parrot_hash_put(interp, orig_hash,
@@ -3165,6 +4225,9 @@
CONST_STRING(interp, "exists_keyed_str"),
vt_orig->exists_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "defined"),
+ vt_orig->defined);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "defined_keyed"),
vt_orig->defined_keyed);
parrot_hash_put(interp, orig_hash,
@@ -3183,6 +4246,12 @@
CONST_STRING(interp, "delete_keyed_str"),
vt_orig->delete_keyed_str);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_iter"),
+ vt_orig->get_iter);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "hashvalue"),
+ vt_orig->hashvalue);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "invoke"),
vt_orig->invoke);
parrot_hash_put(interp, orig_hash,
@@ -3213,6 +4282,9 @@
CONST_STRING(interp, "set_attr_keyed"),
vt_orig->set_attr_keyed);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "get_class"),
+ vt_orig->get_class);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "add_parent"),
vt_orig->add_parent);
parrot_hash_put(interp, orig_hash,
@@ -3243,6 +4315,9 @@
CONST_STRING(interp, "remove_vtable_override"),
vt_orig->remove_vtable_override);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "inspect"),
+ vt_orig->inspect);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "inspect_str"),
vt_orig->inspect_str);
parrot_hash_put(interp, orig_hash,
@@ -3258,29 +4333,741 @@
CONST_STRING(interp, "visit"),
vt_orig->visit);
parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "share"),
+ vt_orig->share);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "share_ro"),
+ vt_orig->share_ro);
+ parrot_hash_put(interp, orig_hash,
CONST_STRING(interp, "init_int"),
vt_orig->init_int);
/* END vtable mapping name original */
}
-/* BEGIN vtable stubs */
+/* BEGIN vtable stubs */
+static
+void stub_init(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->init(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "init"));
+
+ return;
+}
+
+static
+void stub_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->init_pmc(interp, pmc, initializer);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, initializer);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "init_pmc"));
+
+ return;
+}
+
+static
+PMC* stub_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->instantiate(interp, pmc, sig);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, sig);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "instantiate"));
+
+ return ret;
+}
+
+static
+void stub_morph(PARROT_INTERP, PMC* pmc, PMC* type) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->morph(interp, pmc, type);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, type);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "morph"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "morph"));
+
+ return;
+}
+
+static
+void stub_mark(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->mark(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "mark"));
+
+ return;
+}
+
+static
+void stub_destroy(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->destroy(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "destroy"));
+
+ return;
+}
+
+static
+PMC* stub_get_namespace(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_namespace(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "get_namespace"));
+
+ return ret;
+}
+
+static
+PMC* stub_getprop(PARROT_INTERP, PMC* pmc, STRING* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->getprop(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "getprop"));
+
+ return ret;
+}
+
+static
+void stub_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->setprop(interp, pmc, key, value);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "setprop"));
+
+ return;
+}
+
+static
+void stub_delprop(PARROT_INTERP, PMC* pmc, STRING* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->delprop(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "delprop"));
+
+ return;
+}
+
+static
+PMC* stub_getprops(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->getprops(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "getprops"));
+
+ return ret;
+}
+
+static
+INTVAL stub_type(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->type(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "type"));
+
+ return ret;
+}
+
+static
+STRING* stub_name(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->name(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "name"));
+
+ return ret;
+}
+
+static
+PMC* stub_clone(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->clone(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "clone"));
+
+ return ret;
+}
+
+static
+PMC* stub_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->clone_pmc(interp, pmc, args);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, args);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "clone_pmc"));
+
+ return ret;
+}
+
+static
+PMC* stub_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->find_method(interp, pmc, method_name);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, method_name);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "core"),
+ CONST_STRING(supervisor, "find_method"));
+
+ return ret;
+}
+
+static
+INTVAL stub_get_integer(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_integer(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_integer"));
+
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, key);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_integer_keyed"));
+
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed_int(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_integer_keyed_int"));
+
+ return ret;
+}
+
+static
+INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_integer_keyed_str(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_integer_keyed_str"));
+
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ FLOATVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_number(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_number"));
+
+ return ret;
+}
+
+static
+FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ FLOATVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_number_keyed(interp, pmc, key);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, key);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_number_keyed"));
+
+ return ret;
+}
+
static
-void stub_init_pmc(PARROT_INTERP, PMC* pmc, PMC* initializer) {
+FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->init_pmc(interp, pmc, initializer);
+ ret = ((_vtable *)orig_vtable)->get_number_keyed_int(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, initializer);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3289,30 +5076,32 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "init_pmc"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_number_keyed_int"));
- return;
+ return ret;
}
static
-PMC* stub_instantiate(PARROT_INTERP, PMC* pmc, PMC* sig) {
+FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->instantiate(interp, pmc, sig);
+ ret = ((_vtable *)orig_vtable)->get_number_keyed_str(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, sig);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3321,29 +5110,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "instantiate"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_number_keyed_str"));
return ret;
}
static
-void stub_morph(PARROT_INTERP, PMC* pmc, PMC* type) {
+STRING* stub_get_string(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->morph(interp, pmc, type);
+ ret = ((_vtable *)orig_vtable)->get_string(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, type);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3352,35 +5141,61 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "morph"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_string"));
+
+ return ret;
+}
+
+static
+STRING* stub_get_repr(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_repr(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "write"),
- CONST_STRING(supervisor, "morph"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_repr"));
- return;
+ return ret;
}
static
-PMC* stub_getprop(PARROT_INTERP, PMC* pmc, STRING* key) {
+STRING* stub_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->getprop(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_string_keyed(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, key);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3389,32 +5204,32 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "getprop"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_string_keyed"));
return ret;
}
static
-void stub_setprop(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
+STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->setprop(interp, pmc, key, value);
+ ret = ((_vtable *)orig_vtable)->get_string_keyed_int(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3423,26 +5238,27 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "setprop"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_string_keyed_int"));
- return;
+ return ret;
}
static
-void stub_delprop(PARROT_INTERP, PMC* pmc, STRING* key) {
+STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->delprop(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_string_keyed_str(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
@@ -3456,30 +5272,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "delprop"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_string_keyed_str"));
- return;
+ return ret;
}
static
-PMC* stub_clone_pmc(PARROT_INTERP, PMC* pmc, PMC* args) {
+INTVAL stub_get_bool(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->clone_pmc(interp, pmc, args);
+ ret = ((_vtable *)orig_vtable)->get_bool(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, args);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3488,14 +5303,14 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "clone_pmc"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_bool"));
return ret;
}
static
-PMC* stub_find_method(PARROT_INTERP, PMC* pmc, STRING* method_name) {
+PMC* stub_get_pmc(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -3508,12 +5323,9 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->find_method(interp, pmc, method_name);
+ ret = ((_vtable *)orig_vtable)->get_pmc(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, method_name);
- VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3522,27 +5334,27 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "core"),
- CONST_STRING(supervisor, "find_method"));
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_pmc"));
return ret;
}
static
-INTVAL stub_get_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_integer_keyed(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
VTABLE_push_pmc(supervisor, params, key);
@@ -3555,26 +5367,26 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_integer_keyed"));
+ CONST_STRING(supervisor, "get_pmc_keyed"));
return ret;
}
static
-INTVAL stub_get_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_integer_keyed_int(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed_int(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_Integer);
@@ -3589,26 +5401,26 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_integer_keyed_int"));
+ CONST_STRING(supervisor, "get_pmc_keyed_int"));
return ret;
}
static
-INTVAL stub_get_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- INTVAL ret;
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_integer_keyed_str(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pmc_keyed_str(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
@@ -3623,26 +5435,57 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_integer_keyed_str"));
+ CONST_STRING(supervisor, "get_pmc_keyed_str"));
return ret;
}
static
-FLOATVAL stub_get_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void* stub_get_pointer(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- FLOATVAL ret;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_number_keyed(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pointer(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "fetch"),
+ CONST_STRING(supervisor, "get_pointer"));
+
+ return ret;
+}
+
+static
+void* stub_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ void* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
VTABLE_push_pmc(supervisor, params, key);
@@ -3655,26 +5498,26 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_number_keyed"));
+ CONST_STRING(supervisor, "get_pointer_keyed"));
return ret;
}
static
-FLOATVAL stub_get_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- FLOATVAL ret;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_number_keyed_int(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed_int(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_Integer);
@@ -3689,26 +5532,26 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_number_keyed_int"));
+ CONST_STRING(supervisor, "get_pointer_keyed_int"));
return ret;
}
static
-FLOATVAL stub_get_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- FLOATVAL ret;
+ void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_number_keyed_str(interp, pmc, key);
+ ret = ((_vtable *)orig_vtable)->get_pointer_keyed_str(interp, pmc, key);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
@@ -3723,29 +5566,30 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_number_keyed_str"));
+ CONST_STRING(supervisor, "get_pointer_keyed_str"));
return ret;
}
static
-STRING* stub_get_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void stub_set_integer_native(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_string_keyed(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_integer_native(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, value);
+ VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3755,30 +5599,30 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_string_keyed"));
+ CONST_STRING(supervisor, "set_integer_native"));
- return ret;
+ return;
}
static
-STRING* stub_get_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_string_keyed_int(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_integer_keyed(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, key);
temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
+ VTABLE_set_integer_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -3789,30 +5633,32 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_string_keyed_int"));
+ CONST_STRING(supervisor, "set_integer_keyed"));
- return ret;
+ return;
}
static
-STRING* stub_get_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_string_keyed_str(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_integer_keyed_int(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -3823,29 +5669,33 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_string_keyed_str"));
+ CONST_STRING(supervisor, "set_integer_keyed_int"));
- return ret;
+ return;
}
static
-PMC* stub_get_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void stub_set_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pmc_keyed(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_integer_keyed_str(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, value);
+ VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3855,30 +5705,29 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pmc_keyed"));
+ CONST_STRING(supervisor, "set_integer_keyed_str"));
- return ret;
+ return;
}
static
-PMC* stub_get_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pmc_keyed_int(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_number_native(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -3889,30 +5738,30 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pmc_keyed_int"));
+ CONST_STRING(supervisor, "set_number_native"));
- return ret;
+ return;
}
static
-PMC* stub_get_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key, FLOATVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pmc_keyed_str(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_number_keyed(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -3923,29 +5772,33 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pmc_keyed_str"));
+ CONST_STRING(supervisor, "set_number_keyed"));
- return ret;
+ return;
}
static
-void* stub_get_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
+void stub_set_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, FLOATVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pointer_keyed(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_number_keyed_int(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
+ VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -3955,30 +5808,32 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pointer_keyed"));
+ CONST_STRING(supervisor, "set_number_keyed_int"));
- return ret;
+ return;
}
static
-void* stub_get_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key) {
+void stub_set_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, FLOATVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pointer_keyed_int(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_number_keyed_str(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -3989,30 +5844,29 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pointer_keyed_int"));
+ CONST_STRING(supervisor, "set_number_keyed_str"));
- return ret;
+ return;
}
static
-void* stub_get_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key) {
+void stub_set_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- void* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->get_pointer_keyed_str(interp, pmc, key);
+ ((_vtable *)orig_vtable)->set_string_native(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4023,13 +5877,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "get_pointer_keyed_str"));
+ CONST_STRING(supervisor, "set_string_native"));
- return ret;
+ return;
}
static
-void stub_set_integer_native(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4041,11 +5895,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_integer_native(interp, pmc, value);
+ ((_vtable *)orig_vtable)->assign_string_native(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4056,13 +5910,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_integer_native"));
+ CONST_STRING(supervisor, "assign_string_native"));
return;
}
static
-void stub_set_integer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, INTVAL value) {
+void stub_set_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4074,12 +5928,12 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_integer_keyed(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_string_keyed(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
VTABLE_push_pmc(supervisor, params, key);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4090,13 +5944,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_integer_keyed"));
+ CONST_STRING(supervisor, "set_string_keyed"));
return;
}
static
-void stub_set_integer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, INTVAL value) {
+void stub_set_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4108,14 +5962,14 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_integer_keyed_int(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_string_keyed_int(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_Integer);
VTABLE_set_integer_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4126,13 +5980,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_integer_keyed_int"));
+ CONST_STRING(supervisor, "set_string_keyed_int"));
return;
}
static
-void stub_set_integer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, INTVAL value) {
+void stub_set_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4144,14 +5998,14 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_integer_keyed_str(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_string_keyed_str(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
VTABLE_set_string_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4162,13 +6016,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_integer_keyed_str"));
+ CONST_STRING(supervisor, "set_string_keyed_str"));
return;
}
static
-void stub_set_number_native(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_set_bool(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4180,11 +6034,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_number_native(interp, pmc, value);
+ ((_vtable *)orig_vtable)->set_bool(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4195,13 +6049,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_number_native"));
+ CONST_STRING(supervisor, "set_bool"));
return;
}
static
-void stub_set_number_keyed(PARROT_INTERP, PMC* pmc, PMC* key, FLOATVAL value) {
+void stub_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4213,13 +6067,10 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_number_keyed(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_pmc(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4229,13 +6080,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_number_keyed"));
+ CONST_STRING(supervisor, "set_pmc"));
return;
}
static
-void stub_set_number_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, FLOATVAL value) {
+void stub_assign_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4247,15 +6098,10 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_number_keyed_int(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->assign_pmc(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4265,13 +6111,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_number_keyed_int"));
+ CONST_STRING(supervisor, "assign_pmc"));
return;
}
static
-void stub_set_number_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, FLOATVAL value) {
+void stub_set_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4283,15 +6129,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_number_keyed_str(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_pmc_keyed(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, key);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4301,13 +6143,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_number_keyed_str"));
+ CONST_STRING(supervisor, "set_pmc_keyed"));
return;
}
static
-void stub_set_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
+void stub_set_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4319,12 +6161,13 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_string_native(interp, pmc, value);
+ ((_vtable *)orig_vtable)->set_pmc_keyed_int(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4334,13 +6177,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_string_native"));
+ CONST_STRING(supervisor, "set_pmc_keyed_int"));
return;
}
static
-void stub_assign_string_native(PARROT_INTERP, PMC* pmc, STRING* value) {
+void stub_set_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4352,12 +6195,13 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->assign_string_native(interp, pmc, value);
+ ((_vtable *)orig_vtable)->set_pmc_keyed_str(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
+ VTABLE_set_string_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4367,13 +6211,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "assign_string_native"));
+ CONST_STRING(supervisor, "set_pmc_keyed_str"));
return;
}
static
-void stub_set_string_keyed(PARROT_INTERP, PMC* pmc, PMC* key, STRING* value) {
+void stub_set_pointer(PARROT_INTERP, PMC* pmc, void* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4385,12 +6229,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_string_keyed(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_pointer(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4401,13 +6244,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_string_keyed"));
+ CONST_STRING(supervisor, "set_pointer"));
return;
}
static
-void stub_set_string_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, STRING* value) {
+void stub_set_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, void* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4419,14 +6262,12 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_string_keyed_int(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_pointer_keyed(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
+ VTABLE_push_pmc(supervisor, params, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4437,13 +6278,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_string_keyed_int"));
+ CONST_STRING(supervisor, "set_pointer_keyed"));
return;
}
static
-void stub_set_string_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, STRING* value) {
+void stub_set_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, void* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4455,14 +6296,14 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_string_keyed_str(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->set_pointer_keyed_int(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, key);
VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4473,13 +6314,13 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_string_keyed_str"));
+ CONST_STRING(supervisor, "set_pointer_keyed_int"));
return;
}
static
-void stub_set_bool(PARROT_INTERP, PMC* pmc, INTVAL value) {
+void stub_set_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, void* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4491,11 +6332,14 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_bool(interp, pmc, value);
+ ((_vtable *)orig_vtable)->set_pointer_keyed_str(interp, pmc, key, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, key);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4506,28 +6350,28 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_bool"));
+ CONST_STRING(supervisor, "set_pointer_keyed_str"));
return;
}
static
-void stub_set_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+INTVAL stub_elements(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pmc(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->elements(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4536,29 +6380,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pmc"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "elements"));
- return;
+ return ret;
}
static
-void stub_assign_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+INTVAL stub_pop_integer(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->assign_pmc(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->pop_integer(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4567,30 +6411,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "assign_pmc"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "pop_integer"));
- return;
+ return ret;
}
static
-void stub_set_pmc_keyed(PARROT_INTERP, PMC* pmc, PMC* key, PMC* value) {
+FLOATVAL stub_pop_float(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pmc_keyed(interp, pmc, key, value);
+ ret = ((_vtable *)orig_vtable)->pop_float(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4599,32 +6442,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pmc_keyed"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "pop_float"));
- return;
+ return ret;
}
static
-void stub_set_pmc_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, PMC* value) {
+STRING* stub_pop_string(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pmc_keyed_int(interp, pmc, key, value);
+ ret = ((_vtable *)orig_vtable)->pop_string(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4633,32 +6473,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pmc_keyed_int"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "pop_string"));
- return;
+ return ret;
}
static
-void stub_set_pmc_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, PMC* value) {
+PMC* stub_pop_pmc(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pmc_keyed_str(interp, pmc, key, value);
+ ret = ((_vtable *)orig_vtable)->pop_pmc(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4667,14 +6504,14 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pmc_keyed_str"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "pop_pmc"));
- return;
+ return ret;
}
static
-void stub_set_pointer(PARROT_INTERP, PMC* pmc, void* value) {
+void stub_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4686,11 +6523,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pointer(interp, pmc, value);
+ ((_vtable *)orig_vtable)->push_integer(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4700,14 +6537,14 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pointer"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "push_integer"));
return;
}
static
-void stub_set_pointer_keyed(PARROT_INTERP, PMC* pmc, PMC* key, void* value) {
+void stub_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4719,12 +6556,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pointer_keyed(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->push_float(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, key);
- temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4734,14 +6570,14 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pointer_keyed"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "push_float"));
return;
}
static
-void stub_set_pointer_keyed_int(PARROT_INTERP, PMC* pmc, INTVAL key, void* value) {
+void stub_push_string(PARROT_INTERP, PMC* pmc, STRING* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4753,14 +6589,11 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pointer_keyed_int(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->push_string(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, temp, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, value);
VTABLE_push_pmc(supervisor, params, temp);
@@ -4770,14 +6603,14 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pointer_keyed_int"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "push_string"));
return;
}
static
-void stub_set_pointer_keyed_str(PARROT_INTERP, PMC* pmc, STRING* key, void* value) {
+void stub_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -4789,15 +6622,10 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->set_pointer_keyed_str(interp, pmc, key, value);
+ ((_vtable *)orig_vtable)->push_pmc(interp, pmc, value);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, key);
- VTABLE_push_pmc(supervisor, params, temp);
- temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4806,31 +6634,29 @@
params);
raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "fetch"),
- CONST_STRING(supervisor, "set_pointer_keyed_str"));
+ CONST_STRING(supervisor, "fetchsize"),
+ CONST_STRING(supervisor, "push_pmc"));
return;
}
static
-void stub_push_integer(PARROT_INTERP, PMC* pmc, INTVAL value) {
+INTVAL stub_shift_integer(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->push_integer(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->shift_integer(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Integer);
- VTABLE_set_integer_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4840,30 +6666,28 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetchsize"),
- CONST_STRING(supervisor, "push_integer"));
+ CONST_STRING(supervisor, "shift_integer"));
- return;
+ return ret;
}
static
-void stub_push_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+FLOATVAL stub_shift_float(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ FLOATVAL ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->push_float(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->shift_float(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4873,30 +6697,28 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetchsize"),
- CONST_STRING(supervisor, "push_float"));
+ CONST_STRING(supervisor, "shift_float"));
- return;
+ return ret;
}
static
-void stub_push_string(PARROT_INTERP, PMC* pmc, STRING* value) {
+STRING* stub_shift_string(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ STRING* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->push_string(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->shift_string(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_String);
- VTABLE_set_string_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4906,28 +6728,28 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetchsize"),
- CONST_STRING(supervisor, "push_string"));
+ CONST_STRING(supervisor, "shift_string"));
- return;
+ return ret;
}
static
-void stub_push_pmc(PARROT_INTERP, PMC* pmc, PMC* value) {
+PMC* stub_shift_pmc(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->push_pmc(interp, pmc, value);
+ ret = ((_vtable *)orig_vtable)->shift_pmc(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, value);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -4937,9 +6759,9 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "fetchsize"),
- CONST_STRING(supervisor, "push_pmc"));
+ CONST_STRING(supervisor, "shift_pmc"));
- return;
+ return ret;
}
static
@@ -6319,16 +8141,150 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "math"),
- CONST_STRING(supervisor, "i_modulus_int"));
- raise_vtable_event(supervisor, interp, pmc, data,
- CONST_STRING(supervisor, "write"),
- CONST_STRING(supervisor, "i_modulus_int"));
+ CONST_STRING(supervisor, "i_modulus_int"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "i_modulus_int"));
+
+ return;
+}
+
+static
+void stub_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->i_modulus_float(interp, pmc, value);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, value);
+ VTABLE_push_pmc(supervisor, params, temp);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "math"),
+ CONST_STRING(supervisor, "i_modulus_float"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "i_modulus_float"));
+
+ return;
+}
+
+static
+void stub_increment(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->increment(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "math"),
+ CONST_STRING(supervisor, "increment"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "increment"));
+
+ return;
+}
+
+static
+void stub_decrement(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->decrement(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "math"),
+ CONST_STRING(supervisor, "decrement"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "decrement"));
+
+ return;
+}
+
+static
+PMC* stub_absolute(PARROT_INTERP, PMC* pmc, PMC* dest) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->absolute(interp, pmc, dest);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, dest);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "math"),
+ CONST_STRING(supervisor, "absolute"));
- return;
+ return ret;
}
static
-void stub_i_modulus_float(PARROT_INTERP, PMC* pmc, FLOATVAL value) {
+void stub_i_absolute(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -6340,12 +8296,9 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ((_vtable *)orig_vtable)->i_modulus_float(interp, pmc, value);
+ ((_vtable *)orig_vtable)->i_absolute(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- temp = Parrot_pmc_new(supervisor, enum_class_Float);
- VTABLE_set_number_native(supervisor, temp, value);
- VTABLE_push_pmc(supervisor, params, temp);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -6355,16 +8308,16 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "math"),
- CONST_STRING(supervisor, "i_modulus_float"));
+ CONST_STRING(supervisor, "i_absolute"));
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "write"),
- CONST_STRING(supervisor, "i_modulus_float"));
+ CONST_STRING(supervisor, "i_absolute"));
return;
}
static
-PMC* stub_absolute(PARROT_INTERP, PMC* pmc, PMC* dest) {
+PMC* stub_neg(PARROT_INTERP, PMC* pmc, PMC* dest) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
@@ -6377,7 +8330,7 @@
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->absolute(interp, pmc, dest);
+ ret = ((_vtable *)orig_vtable)->neg(interp, pmc, dest);
VTABLE_push_pmc(supervisor, params, pmc);
VTABLE_push_pmc(supervisor, params, dest);
@@ -6390,29 +8343,27 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "math"),
- CONST_STRING(supervisor, "absolute"));
+ CONST_STRING(supervisor, "neg"));
return ret;
}
static
-PMC* stub_neg(PARROT_INTERP, PMC* pmc, PMC* dest) {
+void stub_i_neg(PARROT_INTERP, PMC* pmc) {
PMC *instr_vt, *data;
void *orig_vtable;
Parrot_Interp supervisor;
PMC *temp;
PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
- PMC* ret;
instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
- ret = ((_vtable *)orig_vtable)->neg(interp, pmc, dest);
+ ((_vtable *)orig_vtable)->i_neg(interp, pmc);
VTABLE_push_pmc(supervisor, params, pmc);
- VTABLE_push_pmc(supervisor, params, dest);
data = Parrot_pmc_new(supervisor, enum_class_Hash);
@@ -6422,9 +8373,12 @@
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "math"),
- CONST_STRING(supervisor, "neg"));
+ CONST_STRING(supervisor, "i_neg"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "i_neg"));
- return ret;
+ return;
}
static
@@ -6815,6 +8769,39 @@
}
static
+void stub_i_logical_not(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->i_logical_not(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "cmp"),
+ CONST_STRING(supervisor, "i_logical_not"));
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "write"),
+ CONST_STRING(supervisor, "i_logical_not"));
+
+ return;
+}
+
+static
PMC* stub_concatenate(PARROT_INTERP, PMC* pmc, PMC* value, PMC* dest) {
PMC *instr_vt, *data;
void *orig_vtable;
@@ -7265,6 +9252,37 @@
}
static
+INTVAL stub_defined(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->defined(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "defined"));
+
+ return ret;
+}
+
+static
INTVAL stub_defined_keyed(PARROT_INTERP, PMC* pmc, PMC* key) {
PMC *instr_vt, *data;
void *orig_vtable;
@@ -7462,6 +9480,68 @@
}
static
+PMC* stub_get_iter(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_iter(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "get_iter"));
+
+ return ret;
+}
+
+static
+INTVAL stub_hashvalue(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ INTVAL ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->hashvalue(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "hashvalue"));
+
+ return ret;
+}
+
+static
opcode_t* stub_invoke(PARROT_INTERP, PMC* pmc, void* next) {
PMC *instr_vt, *data;
void *orig_vtable;
@@ -7806,6 +9886,37 @@
}
static
+PMC* stub_get_class(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->get_class(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "get_class"));
+
+ return ret;
+}
+
+static
void stub_add_parent(PARROT_INTERP, PMC* pmc, PMC* parent) {
PMC *instr_vt, *data;
void *orig_vtable;
@@ -8161,6 +10272,37 @@
}
static
+PMC* stub_inspect(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->inspect(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "inspect"));
+
+ return ret;
+}
+
+static
PMC* stub_inspect_str(PARROT_INTERP, PMC* pmc, STRING* what) {
PMC *instr_vt, *data;
void *orig_vtable;
@@ -8325,6 +10467,67 @@
}
static
+void stub_share(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ((_vtable *)orig_vtable)->share(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "share"));
+
+ return;
+}
+
+static
+PMC* stub_share_ro(PARROT_INTERP, PMC* pmc) {
+ PMC *instr_vt, *data;
+ void *orig_vtable;
+ Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
+ PMC* ret;
+
+ instr_vt = (PMC *) parrot_hash_get(interp, vtable_registry, pmc->vtable);
+
+ GETATTR_InstrumentVtable_original_struct(interp, instr_vt, orig_vtable);
+ GETATTR_InstrumentVtable_supervisor(interp, instr_vt, supervisor);
+
+ ret = ((_vtable *)orig_vtable)->share_ro(interp, pmc);
+
+ VTABLE_push_pmc(supervisor, params, pmc);
+
+
+ data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_vtable_event(supervisor, interp, pmc, data,
+ CONST_STRING(supervisor, "main"),
+ CONST_STRING(supervisor, "share_ro"));
+
+ return ret;
+}
+
+static
void stub_init_int(PARROT_INTERP, PMC* pmc, INTVAL initializer) {
PMC *instr_vt, *data;
void *orig_vtable;
Modified: branches/gsoc_instrument/tools/build/gen_gc_stubs.pl
==============================================================================
--- branches/gsoc_instrument/tools/build/gen_gc_stubs.pl Fri Jul 16 17:46:16 2010 (r48100)
+++ branches/gsoc_instrument/tools/build/gen_gc_stubs.pl Sat Jul 17 13:32:21 2010 (r48101)
@@ -36,7 +36,8 @@
flock($dynpmc_fh, LOCK_EX) or die "Cannot lock $dynpmc_file!";
flock($source_fh, LOCK_EX) or die "Cannot lock $source_file!";
-my(%groups, @entries, @prototypes, @stubs);
+my(%groups, @entries, @prototypes, @stubs, %stub_memory_sizes);
+init_stub_memory_sizes(\%stub_memory_sizes);
# Read the whole file.
my $contents = join('', map { chomp;$_; } <$source_fh>);
@@ -79,6 +80,7 @@
push(@{$groups{'administration'}}, $data[1]);
push @data, 'administration';
}
+ push @{$groups{'all'}}, $data[1];
push @prototypes, gen_prototype(@data);
push @stubs, gen_stub(@data);
@@ -220,6 +222,9 @@
}
}
+ # For allocations and reallocations, expose the size of the allocation.
+ my $alloc = $stub_memory_sizes{$name} || '';
+
return <<STUB;
$ret stub_$name($params) {
GC_Subsystem *gc_orig = ((InstrumentGC_Subsystem *) interp->gc_sys)->original;
@@ -240,7 +245,7 @@
VTABLE_set_pmc_keyed_str(supervisor, event_data,
CONST_STRING(supervisor, "parameters"),
params);
-
+$alloc
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "$group"), event_data);
return$ret_last;
@@ -368,6 +373,39 @@
return join(', ', @param_list);
}
+sub init_stub_memory_sizes {
+ my $ref = shift;
+
+ my %sources = (
+ 'allocate_pmc_header' => 'sizeof (PMC)',
+ 'allocate_string_header' => 'sizeof (STRING)',
+ 'allocate_bufferlike_header' => 'sizeof (Buffer)',
+ 'allocate_pmc_attributes' => 'VTABLE_get_pmc_keyed_int(supervisor, params, 0)->vtable->attr_size',
+ 'allocate_string_storage' => 'size',
+ 'allocate_buffer_storage' => 'nsize',
+ 'allocate_fixed_size_storage' => 'size',
+ 'allocate_memory_chunk' => 'size',
+ 'allocate_memory_chunk_with_interior_pointers' => 'size',
+ 'reallocate_string_storage' => 'size',
+ 'reallocate_buffer_storage' => 'newsize',
+ 'reallocate_memory_chunk' => 'newsize',
+ 'reallocate_memory_chunk_with_interior_pointers' => 'newsize'
+ );
+
+ my $key;
+ for $key (keys %sources) {
+ my $source = $sources{$key};
+ $ref->{$key} = <<SIZE;
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp,
+ $source);
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "size"),
+ temp);
+SIZE
+ }
+}
+
# Local Variables:
# mode: cperl
# cperl-indent-level: 4
Modified: branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
==============================================================================
--- branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Fri Jul 16 17:46:16 2010 (r48100)
+++ branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sat Jul 17 13:32:21 2010 (r48101)
@@ -72,6 +72,7 @@
push @{$groups{$annotation}}, $data[1];
push @groups, $annotation;
}
+ push @{$groups{'all'}}, $data[1];
push @{$groups{$cur_group}}, $data[1];
push @data, \@groups;
More information about the parrot-commits
mailing list