[svn:parrot] r48066 - in branches/gsoc_instrument: src/dynpmc tools/build
khairul at svn.parrot.org
khairul at svn.parrot.org
Sat Jul 10 16:53:16 UTC 2010
Author: khairul
Date: Sat Jul 10 16:53:15 2010
New Revision: 48066
URL: https://trac.parrot.org/parrot/changeset/48066
Log:
Added generator for gc stubs.
Added:
branches/gsoc_instrument/tools/build/gen_gc_stubs.pl
Modified:
branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
Modified: branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Sat Jul 10 15:54:19 2010 (r48065)
+++ branches/gsoc_instrument/src/dynpmc/instrumentgc.pmc Sat Jul 10 16:53:15 2010 (r48066)
@@ -70,37 +70,38 @@
/* Prototypes for stub functions. */
/* BEGIN gc prototypes */
-PMC* stub_allocate_pmc_header(PARROT_INTERP, UINTVAL flags);
-void* stub_allocate_pmc_attributes(PARROT_INTERP, PMC *pmc);
-void* stub_allocate_memory_chunk(PARROT_INTERP, size_t size);
-void* stub_allocate_memory_chunk_with_interior_pointers(PARROT_INTERP, size_t size);
-STRING* stub_allocate_string_header(PARROT_INTERP, UINTVAL flags);
-void stub_allocate_string_storage(PARROT_INTERP, STRING *str, size_t size);
-Buffer* stub_allocate_bufferlike_header(PARROT_INTERP, size_t size);
-void stub_allocate_buffer_storage(PARROT_INTERP, ARGMOD(Buffer *buffer), size_t nsize);
-void* stub_allocate_fixed_size_storage(PARROT_INTERP, size_t size);
-void stub_reallocate_string_storage(PARROT_INTERP, STRING *str, size_t size);
-void stub_reallocate_buffer_storage(PARROT_INTERP, ARGMOD(Buffer *buffer), size_t newsize);
-void* stub_reallocate_memory_chunk(PARROT_INTERP, void *data, size_t newsize);
-void* stub_reallocate_memory_chunk_with_interior_pointers(PARROT_INTERP, void *data,
- size_t oldsize, size_t newsize);
-void stub_free_pmc_header(PARROT_INTERP, PMC *pmc);
-void stub_free_string_header(PARROT_INTERP, STRING *string);
-void stub_free_bufferlike_header(PARROT_INTERP, Buffer *buffer, size_t size);
-void stub_free_pmc_attributes(PARROT_INTERP, PMC *pmc);
-void stub_free_fixed_size_storage(PARROT_INTERP, size_t size, void *ptr);
-void stub_free_memory_chunk(PARROT_INTERP, void *data);
-void stub_do_gc_mark(PARROT_INTERP, UINTVAL flags);
-void stub_block_mark(PARROT_INTERP);
-void stub_unblock_mark(PARROT_INTERP);
-void stub_block_sweep(PARROT_INTERP);
-void stub_unblock_sweep(PARROT_INTERP);
-void stub_finalize_gc_system(PARROT_INTERP);
-void stub_destroy_child_interp(Interp *dest_interp, Interp *child_interp);
-void stub_compact_string_pool(PARROT_INTERP);
-void stub_mark_special(PARROT_INTERP, PMC *pmc);
-void stub_pmc_needs_early_collection(PARROT_INTERP, PMC *pmc);
-void stub_init_pool(PARROT_INTERP, struct Fixed_Size_Pool *pool);
+void stub_finalize_gc_system(PARROT_INTERP);
+void stub_destroy_child_interp(Interp* dest_interp, Interp* child_interp);
+void stub_do_gc_mark(PARROT_INTERP, UINTVAL flags);
+void stub_compact_string_pool(PARROT_INTERP);
+void stub_mark_special(PARROT_INTERP, PMC* stub_var1);
+void stub_pmc_needs_early_collection(PARROT_INTERP, PMC* stub_var1);
+void stub_init_pool(PARROT_INTERP, struct Fixed_Size_Pool* stub_var1);
+PMC* stub_allocate_pmc_header(PARROT_INTERP, UINTVAL flags);
+void stub_free_pmc_header(PARROT_INTERP, PMC* stub_var1);
+STRING* stub_allocate_string_header(PARROT_INTERP, UINTVAL flags);
+void stub_free_string_header(PARROT_INTERP, STRING* stub_var1);
+Buffer* stub_allocate_bufferlike_header(PARROT_INTERP, size_t size);
+void stub_free_bufferlike_header(PARROT_INTERP, Buffer* stub_var1, size_t size);
+void* stub_allocate_pmc_attributes(PARROT_INTERP, PMC* stub_var1);
+void stub_free_pmc_attributes(PARROT_INTERP, PMC* stub_var1);
+void stub_allocate_string_storage(PARROT_INTERP, STRING* str, size_t size);
+void stub_reallocate_string_storage(PARROT_INTERP, STRING* str, size_t size);
+void stub_allocate_buffer_storage(PARROT_INTERP, Buffer* buffer, size_t nsize);
+void stub_reallocate_buffer_storage(PARROT_INTERP, Buffer* buffer, size_t newsize);
+void* stub_allocate_fixed_size_storage(PARROT_INTERP, size_t size);
+void stub_free_fixed_size_storage(PARROT_INTERP, size_t size, void* stub_var1);
+void* stub_allocate_memory_chunk(PARROT_INTERP, size_t size);
+void* stub_reallocate_memory_chunk(PARROT_INTERP, void* data, size_t newsize);
+void* stub_allocate_memory_chunk_with_interior_pointers(PARROT_INTERP, size_t size);
+void* stub_reallocate_memory_chunk_with_interior_pointers(PARROT_INTERP, void* data,
+ size_t oldsize, size_t newsize);
+void stub_free_memory_chunk(PARROT_INTERP, void* data);
+void stub_block_mark(PARROT_INTERP);
+void stub_unblock_mark(PARROT_INTERP);
+void stub_block_sweep(PARROT_INTERP);
+void stub_unblock_sweep(PARROT_INTERP);
+
/* END gc prototypes */
/* Prototypes for helper functions. */
@@ -336,48 +337,79 @@
list = Parrot_pmc_new(INTERP, enum_class_ResizableStringArray);
- if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "allocate"))) {
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_pmc_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_string_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_bufferlike_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_pmc_attributes"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_string_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_buffer_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_fixed_size_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "allocate_memory_chunk"));
- VTABLE_push_string(INTERP, list,
- CONST_STRING(INTERP, "allocate_memory_chunk_with_interior_pointers"));
+ /* BEGIN gc groupings */
+ if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "free"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_pmc_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_string_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_bufferlike_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_pmc_attributes"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_fixed_size_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "free_memory_chunk"));
}
- else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "reallocate"))) {
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "reallocate_string_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "reallocate_buffer_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "reallocate_memory_chunk"));
- VTABLE_push_string(INTERP, list,
- CONST_STRING(INTERP, "reallocate_memory_chunk_with_interior_pointers"));
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "administration"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "finalize_gc_system"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "destroy_child_interp"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "do_gc_mark"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "compact_string_pool"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "mark_special"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "pmc_needs_early_collection"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "init_pool"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "block_mark"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unblock_mark"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "block_sweep"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unblock_sweep"));
}
- else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "free"))) {
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_pmc_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_string_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_bufferlike_header"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_pmc_attributes"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_fixed_size_storage"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "free_memory_chunk"));
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "allocate"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_pmc_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_string_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_bufferlike_header"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_pmc_attributes"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_string_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_buffer_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_fixed_size_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_memory_chunk"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "allocate_memory_chunk_with_interior_pointers"));
}
- else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "administration"))) {
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "finalize_gc_system"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "destroy_child_interp"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "do_gc_mark"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "compact_string_pool"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "mark_special"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "pmc_needs_early_collection"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "init_pool"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "block_mark"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "unblock_mark"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "block_sweep"));
- VTABLE_push_string(INTERP, list, CONST_STRING(INTERP, "unblock_sweep"));
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "reallocate"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "reallocate_string_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "reallocate_buffer_storage"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "reallocate_memory_chunk"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "reallocate_memory_chunk_with_interior_pointers"));
}
+
+ /* END gc groupings */
else {
- /* Ensure that con_str is the name of a hook before pushing it in. */
+ /* Ensure that name is the name of a hook before pushing it in. */
size_t *check;
Hash *stub_hash;
@@ -406,736 +438,866 @@
*/
/* BEGIN gc stubs */
-/*
- * Allocations
- */
-PMC* stub_allocate_pmc_header(PARROT_INTERP, UINTVAL flags) {
+void stub_finalize_gc_system(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- PMC *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ gc_orig->finalize_gc_system(interp);
- ret = gc_orig->allocate_pmc_header(interp, flags);
-
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_pmc_header"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "flags"), flags);
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), sizeof (struct PMC));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "finalize_gc_system"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-void* stub_allocate_pmc_attributes(PARROT_INTERP, PMC *pmc) {
+void stub_destroy_child_interp(Interp* interp, Interp* child_interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ gc_orig->destroy_child_interp(interp, child_interp);
- ret = gc_orig->allocate_pmc_attributes(interp, pmc);
-
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, child_interp);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_pmc_attributes"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), pmc->vtable->attr_size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
- VTABLE_set_string_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "pmc_type"),
- VTABLE_name(interp, pmc));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "destroy_child_interp"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-STRING* stub_allocate_string_header(PARROT_INTERP, UINTVAL flags) {
+void stub_do_gc_mark(Parrot_Interp interp, UINTVAL flags) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- STRING *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ gc_orig->do_gc_mark(interp, flags);
- ret = gc_orig->allocate_string_header(interp, flags);
-
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, flags);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_string_header"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "flags"), flags);
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), sizeof (struct parrot_string_t));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "do_gc_mark"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-void stub_allocate_string_storage(PARROT_INTERP, STRING *str, size_t size) {
+void stub_compact_string_pool(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ gc_orig->compact_string_pool(interp);
- gc_orig->allocate_string_storage(interp, str, size);
-
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, str);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_string_storage"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "compact_string_pool"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
return;
}
-void* stub_allocate_memory_chunk(PARROT_INTERP, size_t size) {
+void stub_mark_special(Parrot_Interp interp, PMC* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->allocate_memory_chunk(interp, size);
+ gc_orig->mark_special(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_memory_chunk"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "mark_special"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-void* stub_allocate_memory_chunk_with_interior_pointers(PARROT_INTERP, size_t size) {
+void stub_pmc_needs_early_collection(Parrot_Interp interp, PMC* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->allocate_memory_chunk_with_interior_pointers(interp, size);
+ gc_orig->pmc_needs_early_collection(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_memory_chunk_with_interior_pointers"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "pmc_needs_early_collection"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-Buffer* stub_allocate_bufferlike_header(PARROT_INTERP, size_t size) {
+void stub_init_pool(Parrot_Interp interp, struct Fixed_Size_Pool* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- Buffer *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->allocate_bufferlike_header(interp, size);
+ gc_orig->init_pool(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_bufferlike_header"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "init_pool"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
- return ret;
+ return;
}
-void stub_allocate_buffer_storage(PARROT_INTERP, ARGMOD(Buffer *buffer), size_t nsize) {
+PMC* stub_allocate_pmc_header(Parrot_Interp interp, UINTVAL flags) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ PMC* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->allocate_buffer_storage(interp, buffer, nsize);
+ ret = gc_orig->allocate_pmc_header(interp, flags);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, buffer);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, flags);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_buffer_storage"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"), nsize);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_pmc_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void* stub_allocate_fixed_size_storage(PARROT_INTERP, size_t size) {
+void stub_free_pmc_header(Parrot_Interp interp, PMC* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->allocate_fixed_size_storage(interp, size);
+ gc_orig->free_pmc_header(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, ret);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "allocate_fixed_size_storage"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_pmc_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
- return ret;
+ return;
}
-/*
- * Reallocations
- */
-
-void stub_reallocate_string_storage(PARROT_INTERP, STRING *str, size_t size) {
+STRING* stub_allocate_string_header(Parrot_Interp interp, UINTVAL flags) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ STRING* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ ret = gc_orig->allocate_string_header(interp, flags);
- gc_orig->reallocate_string_storage(interp, str, size);
-
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, str);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, flags);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "reallocate_string_storage"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"), size);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_string_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void stub_reallocate_buffer_storage(PARROT_INTERP, ARGMOD(Buffer *buffer), size_t newsize) {
+void stub_free_string_header(Parrot_Interp interp, STRING* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->reallocate_buffer_storage(interp, buffer, newsize);
+ gc_orig->free_string_header(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, buffer);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "reallocate_buffer_storage"));
- VTABLE_set_integer_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "size"), newsize);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_string_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
return;
}
-void* stub_reallocate_memory_chunk(PARROT_INTERP, void *data, size_t newsize) {
+Buffer* stub_allocate_bufferlike_header(Parrot_Interp interp, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ Buffer* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->reallocate_memory_chunk(interp, data, newsize);
+ ret = gc_orig->allocate_bufferlike_header(interp, size);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, data);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "reallocate_memory_chunk"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), newsize);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_bufferlike_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
return ret;
}
-void* stub_reallocate_memory_chunk_with_interior_pointers(PARROT_INTERP, void *data,
- size_t oldsize, size_t newsize) {
+void stub_free_bufferlike_header(Parrot_Interp interp, Buffer* stub_var1, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- void *ret;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- ret = gc_orig->reallocate_memory_chunk_with_interior_pointers(interp, data, oldsize, newsize);
+ gc_orig->free_bufferlike_header(interp, stub_var1, size);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, data);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "reallocate_memory_chunk_with_interior_pointers"));
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "size"), newsize);
- VTABLE_set_integer_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "oldsize"), oldsize);
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_bufferlike_header"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
- return ret;
+ return;
}
-/*
- * Frees
- */
-void stub_free_pmc_header(PARROT_INTERP, PMC *pmc) {
+void* stub_allocate_pmc_attributes(Parrot_Interp interp, PMC* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- STRING *pmc_type;
-
- pmc_type = VTABLE_name(interp, pmc);
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_pmc_header(interp, pmc);
+ ret = gc_orig->allocate_pmc_attributes(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_pmc_header"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
- VTABLE_set_string_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "pmc_type"),
- pmc_type);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_pmc_attributes"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void stub_free_pmc_attributes(PARROT_INTERP, PMC *pmc) {
+void stub_free_pmc_attributes(Parrot_Interp interp, PMC* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- STRING *pmc_type;
-
- pmc_type = VTABLE_name(interp, pmc);
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_pmc_attributes(interp, pmc);
+ gc_orig->free_pmc_attributes(interp, stub_var1);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_pmc_attributes"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
- VTABLE_set_string_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "pmc_type"),
- pmc_type);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_pmc_attributes"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
return;
}
-void stub_free_string_header(PARROT_INTERP, STRING* string) {
+void stub_allocate_string_storage(Parrot_Interp interp, STRING* str, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_string_header(interp, string);
+ gc_orig->allocate_string_storage(interp, str, size);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, string);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, str);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_string_header"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_string_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
return;
}
-void stub_free_bufferlike_header(PARROT_INTERP, Buffer *buffer, size_t size) {
+void stub_reallocate_string_storage(Parrot_Interp interp, STRING* str, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_bufferlike_header(interp, buffer, size);
+ gc_orig->reallocate_string_storage(interp, str, size);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, buffer);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, str);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_bufferlike_header"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "reallocate_string_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
return;
}
-void stub_free_fixed_size_storage(PARROT_INTERP, size_t size, void *ptr) {
+void stub_allocate_buffer_storage(Parrot_Interp interp, Buffer* buffer, size_t nsize) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr_obj;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_fixed_size_storage(interp, size, ptr);
+ gc_orig->allocate_buffer_storage(interp, buffer, nsize);
- ptr_obj = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr_obj, ptr);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, buffer);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, nsize);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_fixed_size_storage"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr_obj);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_buffer_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
return;
}
-void stub_free_memory_chunk(PARROT_INTERP, void *data) {
+void stub_reallocate_buffer_storage(Parrot_Interp interp, Buffer* buffer, size_t newsize) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->free_memory_chunk(interp, data);
+ gc_orig->reallocate_buffer_storage(interp, buffer, newsize);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, data);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, buffer);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, newsize);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "free_memory_chunk"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "reallocate_buffer_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
return;
}
-/*
- * Administration
- */
-void stub_do_gc_mark(PARROT_INTERP, UINTVAL flags) {
+void* stub_allocate_fixed_size_storage(Parrot_Interp interp, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->do_gc_mark(interp, flags);
+ ret = gc_orig->allocate_fixed_size_storage(interp, size);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "do_gc_mark"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_fixed_size_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void stub_block_mark(PARROT_INTERP) {
+void stub_free_fixed_size_storage(Parrot_Interp interp, size_t size, void* stub_var1) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->block_mark(interp);
+ gc_orig->free_fixed_size_storage(interp, size, stub_var1);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, stub_var1);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "block_mark"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_fixed_size_storage"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
return;
}
-void stub_unblock_mark(PARROT_INTERP) {
+void* stub_allocate_memory_chunk(Parrot_Interp interp, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->unblock_mark(interp);
+ ret = gc_orig->allocate_memory_chunk(interp, size);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "unblock_mark"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_memory_chunk"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void stub_block_sweep(PARROT_INTERP) {
+void* stub_reallocate_memory_chunk(Parrot_Interp interp, void* data, size_t newsize) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->block_sweep(interp);
+ ret = gc_orig->reallocate_memory_chunk(interp, data, newsize);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, data);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, newsize);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "block_sweep"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "reallocate_memory_chunk"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
- return;
+ return ret;
}
-void stub_unblock_sweep(PARROT_INTERP) {
+void* stub_allocate_memory_chunk_with_interior_pointers(Parrot_Interp interp, size_t size) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->unblock_sweep(interp);
+ ret = gc_orig->allocate_memory_chunk_with_interior_pointers(interp, size);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, size);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "unblock_sweep"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "allocate_memory_chunk_with_interior_pointers"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "allocate"), event_data);
- return;
+ return ret;
}
-void stub_finalize_gc_system(PARROT_INTERP) {
+void* stub_reallocate_memory_chunk_with_interior_pointers(Parrot_Interp interp, void* data,
+ size_t oldsize, size_t newsize) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+ void* ret;
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->finalize_gc_system(interp);
+ ret = gc_orig->reallocate_memory_chunk_with_interior_pointers(interp, data, oldsize, newsize);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, data);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, oldsize);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, newsize);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "finalize_gc_system"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "reallocate_memory_chunk_with_interior_pointers"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "reallocate"), event_data);
- return;
+ return ret;
}
-void stub_destroy_child_interp(Interp *dest_interp, Interp *child_interp) {
- PMC *instr_gc = ((InstrumentGC_Subsystem *) dest_interp->gc_sys)->instrument_gc;
- Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) dest_interp->gc_sys)->supervisor;
+void stub_free_memory_chunk(Parrot_Interp interp, void* data) {
+ PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
+ Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->destroy_child_interp(dest_interp, child_interp);
+ gc_orig->free_memory_chunk(interp, data);
+
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, data);
+ VTABLE_push_pmc(supervisor, params, temp);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "destroy_child_interp"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "free_memory_chunk"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
- raise_gc_event(supervisor, dest_interp, CONST_STRING(supervisor, "administration"), event_data);
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "free"), event_data);
return;
}
-void stub_compact_string_pool(PARROT_INTERP) {
+void stub_block_mark(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->compact_string_pool(interp);
+ gc_orig->block_mark(interp);
+
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "compact_string_pool"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "block_mark"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
return;
}
-void stub_mark_special(PARROT_INTERP, PMC *pmc) {
+void stub_unblock_mark(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- STRING *pmc_type;
-
- pmc_type = VTABLE_name(interp, pmc);
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->mark_special(interp, pmc);
+ gc_orig->unblock_mark(interp);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, pmc);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "mark_special"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
- VTABLE_set_string_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "pmc_type"),
- pmc_type);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "unblock_mark"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
return;
}
-void stub_pmc_needs_early_collection(PARROT_INTERP, PMC *pmc) {
+void stub_block_sweep(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
- PMC *event_data, *ptr;
- STRING *pmc_type;
-
- pmc_type = VTABLE_name(interp, pmc);
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->pmc_needs_early_collection(interp, pmc);
+ gc_orig->block_sweep(interp);
- ptr = Parrot_pmc_new(supervisor, enum_class_Pointer);
- VTABLE_set_pointer(supervisor, ptr, pmc);
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "pmc_needs_early_collection"));
- VTABLE_set_pmc_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "address"), ptr);
- VTABLE_set_string_keyed_str(supervisor, event_data, CONST_STRING(supervisor, "pmc_type"),
- pmc_type);
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "block_sweep"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
return;
}
-void stub_init_pool(PARROT_INTERP, struct Fixed_Size_Pool *pool) {
+void stub_unblock_sweep(Parrot_Interp interp) {
PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
GC_Subsystem *gc_orig;
PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
- gc_orig->init_pool(interp, pool);
+ gc_orig->unblock_sweep(interp);
+
event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
VTABLE_set_string_keyed_str(supervisor, event_data,
- CONST_STRING(supervisor, "type"),
- CONST_STRING(supervisor, "init_pool"));
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "unblock_sweep"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "administration"), event_data);
return;
}
+
/* END gc stubs */
/*
@@ -1191,196 +1353,284 @@
InstrumentGC_Subsystem *gc_instr, GC_Subsystem *gc_orig) {
/* BEGIN gc mappings */
/* Build the pointer hash to the stubs. */
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "finalize_gc_system"),
- stub_finalize_gc_system);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "destroy_child_interp"),
- stub_destroy_child_interp);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "do_gc_mark"),
- stub_do_gc_mark);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "compact_string_pool"),
- stub_compact_string_pool);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "mark_special"),
- stub_mark_special);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "pmc_needs_early_collection"),
- stub_pmc_needs_early_collection);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "init_pool"),
- stub_init_pool);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_pmc_header"),
- stub_allocate_pmc_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_pmc_header"),
- stub_free_pmc_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_string_header"),
- stub_allocate_string_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_string_header"),
- stub_free_string_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_bufferlike_header"),
- stub_allocate_bufferlike_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_bufferlike_header"),
- stub_free_bufferlike_header);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_pmc_attributes"),
- stub_allocate_pmc_attributes);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_pmc_attributes"),
- stub_free_pmc_attributes);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_string_storage"),
- stub_allocate_string_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "reallocate_string_storage"),
- stub_reallocate_string_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_buffer_storage"),
- stub_allocate_buffer_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "reallocate_buffer_storage"),
- stub_reallocate_buffer_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_fixed_size_storage"),
- stub_allocate_fixed_size_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_fixed_size_storage"),
- stub_free_fixed_size_storage);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "allocate_memory_chunk"),
- stub_allocate_memory_chunk);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "reallocate_memory_chunk"),
- stub_reallocate_memory_chunk);
- parrot_hash_put(interp, instr_hash,
- CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
- stub_allocate_memory_chunk_with_interior_pointers);
- parrot_hash_put(interp, instr_hash,
- CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
- stub_reallocate_memory_chunk_with_interior_pointers);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "free_memory_chunk"),
- stub_free_memory_chunk);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "block_mark"),
- stub_block_mark);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "unblock_mark"),
- stub_unblock_mark);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "block_sweep"),
- stub_block_sweep);
- parrot_hash_put(interp, instr_hash, CONST_STRING(interp, "unblock_sweep"),
- stub_unblock_sweep);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "finalize_gc_system"),
+ stub_finalize_gc_system);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "destroy_child_interp"),
+ stub_destroy_child_interp);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "do_gc_mark"),
+ stub_do_gc_mark);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "compact_string_pool"),
+ stub_compact_string_pool);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "mark_special"),
+ stub_mark_special);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "pmc_needs_early_collection"),
+ stub_pmc_needs_early_collection);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "init_pool"),
+ stub_init_pool);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_pmc_header"),
+ stub_allocate_pmc_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_pmc_header"),
+ stub_free_pmc_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_string_header"),
+ stub_allocate_string_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_string_header"),
+ stub_free_string_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_bufferlike_header"),
+ stub_allocate_bufferlike_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_bufferlike_header"),
+ stub_free_bufferlike_header);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_pmc_attributes"),
+ stub_allocate_pmc_attributes);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_pmc_attributes"),
+ stub_free_pmc_attributes);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_string_storage"),
+ stub_allocate_string_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "reallocate_string_storage"),
+ stub_reallocate_string_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_buffer_storage"),
+ stub_allocate_buffer_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "reallocate_buffer_storage"),
+ stub_reallocate_buffer_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_fixed_size_storage"),
+ stub_allocate_fixed_size_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_fixed_size_storage"),
+ stub_free_fixed_size_storage);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_memory_chunk"),
+ stub_allocate_memory_chunk);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk"),
+ stub_reallocate_memory_chunk);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
+ stub_allocate_memory_chunk_with_interior_pointers);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
+ stub_reallocate_memory_chunk_with_interior_pointers);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "free_memory_chunk"),
+ stub_free_memory_chunk);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "block_mark"),
+ stub_block_mark);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unblock_mark"),
+ stub_unblock_mark);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "block_sweep"),
+ stub_block_sweep);
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "unblock_sweep"),
+ stub_unblock_sweep);
+
/* Build the pointer hash to the original. */
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "finalize_gc_system"),
- gc_orig->finalize_gc_system);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "destroy_child_interp"),
- gc_orig->destroy_child_interp);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "do_gc_mark"),
- gc_orig->do_gc_mark);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "compact_string_pool"),
- gc_orig->compact_string_pool);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "mark_special"),
- gc_orig->mark_special);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "pmc_needs_early_collection"),
- gc_orig->pmc_needs_early_collection);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "init_pool"),
- gc_orig->init_pool);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_pmc_header"),
- gc_orig->allocate_pmc_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_pmc_header"),
- gc_orig->free_pmc_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_string_header"),
- gc_orig->allocate_string_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_string_header"),
- gc_orig->free_string_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_bufferlike_header"),
- gc_orig->allocate_bufferlike_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_bufferlike_header"),
- gc_orig->free_bufferlike_header);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_pmc_attributes"),
- gc_orig->allocate_pmc_attributes);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_pmc_attributes"),
- gc_orig->free_pmc_attributes);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_string_storage"),
- gc_orig->allocate_string_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "reallocate_string_storage"),
- gc_orig->reallocate_string_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_buffer_storage"),
- gc_orig->allocate_buffer_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "reallocate_buffer_storage"),
- gc_orig->reallocate_buffer_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_fixed_size_storage"),
- gc_orig->allocate_fixed_size_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_fixed_size_storage"),
- gc_orig->free_fixed_size_storage);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "allocate_memory_chunk"),
- gc_orig->allocate_memory_chunk);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "reallocate_memory_chunk"),
- gc_orig->reallocate_memory_chunk);
- parrot_hash_put(interp, orig_hash,
- CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
- gc_orig->allocate_memory_chunk_with_interior_pointers);
- parrot_hash_put(interp, orig_hash,
- CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
- gc_orig->reallocate_memory_chunk_with_interior_pointers);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "free_memory_chunk"),
- gc_orig->free_memory_chunk);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "block_mark"),
- gc_orig->block_mark);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "unblock_mark"),
- gc_orig->unblock_mark);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "block_sweep"),
- gc_orig->block_sweep);
- parrot_hash_put(interp, orig_hash, CONST_STRING(interp, "unblock_sweep"),
- gc_orig->unblock_sweep);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "finalize_gc_system"),
+ gc_orig->finalize_gc_system);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "destroy_child_interp"),
+ gc_orig->destroy_child_interp);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "do_gc_mark"),
+ gc_orig->do_gc_mark);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "compact_string_pool"),
+ gc_orig->compact_string_pool);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "mark_special"),
+ gc_orig->mark_special);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "pmc_needs_early_collection"),
+ gc_orig->pmc_needs_early_collection);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "init_pool"),
+ gc_orig->init_pool);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_pmc_header"),
+ gc_orig->allocate_pmc_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_pmc_header"),
+ gc_orig->free_pmc_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_string_header"),
+ gc_orig->allocate_string_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_string_header"),
+ gc_orig->free_string_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_bufferlike_header"),
+ gc_orig->allocate_bufferlike_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_bufferlike_header"),
+ gc_orig->free_bufferlike_header);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_pmc_attributes"),
+ gc_orig->allocate_pmc_attributes);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_pmc_attributes"),
+ gc_orig->free_pmc_attributes);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_string_storage"),
+ gc_orig->allocate_string_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "reallocate_string_storage"),
+ gc_orig->reallocate_string_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_buffer_storage"),
+ gc_orig->allocate_buffer_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "reallocate_buffer_storage"),
+ gc_orig->reallocate_buffer_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_fixed_size_storage"),
+ gc_orig->allocate_fixed_size_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_fixed_size_storage"),
+ gc_orig->free_fixed_size_storage);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_memory_chunk"),
+ gc_orig->allocate_memory_chunk);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk"),
+ gc_orig->reallocate_memory_chunk);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
+ gc_orig->allocate_memory_chunk_with_interior_pointers);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
+ gc_orig->reallocate_memory_chunk_with_interior_pointers);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "free_memory_chunk"),
+ gc_orig->free_memory_chunk);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "block_mark"),
+ gc_orig->block_mark);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unblock_mark"),
+ gc_orig->unblock_mark);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "block_sweep"),
+ gc_orig->block_sweep);
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "unblock_sweep"),
+ gc_orig->unblock_sweep);
+
/* Build the pointer hash for name to InstrumentGC_Subsystem entry. */
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "finalize_gc_system"),
- &(gc_instr->finalize_gc_system));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "destroy_child_interp"),
- &(gc_instr->destroy_child_interp));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "do_gc_mark"),
- &(gc_instr->do_gc_mark));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "compact_string_pool"),
- &(gc_instr->compact_string_pool));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "mark_special"),
- &(gc_instr->mark_special));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "pmc_needs_early_collection"),
- &(gc_instr->pmc_needs_early_collection));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "init_pool"),
- &(gc_instr->init_pool));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_pmc_header"),
- &(gc_instr->allocate_pmc_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_pmc_header"),
- &(gc_instr->free_pmc_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_string_header"),
- &(gc_instr->allocate_string_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_string_header"),
- &(gc_instr->free_string_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_bufferlike_header"),
- &(gc_instr->allocate_bufferlike_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_bufferlike_header"),
- &(gc_instr->free_bufferlike_header));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_pmc_attributes"),
- &(gc_instr->allocate_pmc_attributes));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_pmc_attributes"),
- &(gc_instr->free_pmc_attributes));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_string_storage"),
- &(gc_instr->allocate_string_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "reallocate_string_storage"),
- &(gc_instr->reallocate_string_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_buffer_storage"),
- &(gc_instr->allocate_buffer_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "reallocate_buffer_storage"),
- &(gc_instr->reallocate_buffer_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_fixed_size_storage"),
- &(gc_instr->allocate_fixed_size_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_fixed_size_storage"),
- &(gc_instr->free_fixed_size_storage));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "allocate_memory_chunk"),
- &(gc_instr->allocate_memory_chunk));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "reallocate_memory_chunk"),
- &(gc_instr->reallocate_memory_chunk));
- parrot_hash_put(interp, entry_hash,
- CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
- &(gc_instr->allocate_memory_chunk_with_interior_pointers));
- parrot_hash_put(interp, entry_hash,
- CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
- &(gc_instr->reallocate_memory_chunk_with_interior_pointers));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "free_memory_chunk"),
- &(gc_instr->free_memory_chunk));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "block_mark"),
- &(gc_instr->block_mark));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "unblock_mark"),
- &(gc_instr->unblock_mark));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "block_sweep"),
- &(gc_instr->block_sweep));
- parrot_hash_put(interp, entry_hash, CONST_STRING(interp, "unblock_sweep"),
- &(gc_instr->unblock_sweep));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "finalize_gc_system"),
+ &(gc_instr->finalize_gc_system));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "destroy_child_interp"),
+ &(gc_instr->destroy_child_interp));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "do_gc_mark"),
+ &(gc_instr->do_gc_mark));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "compact_string_pool"),
+ &(gc_instr->compact_string_pool));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "mark_special"),
+ &(gc_instr->mark_special));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "pmc_needs_early_collection"),
+ &(gc_instr->pmc_needs_early_collection));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "init_pool"),
+ &(gc_instr->init_pool));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_pmc_header"),
+ &(gc_instr->allocate_pmc_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_pmc_header"),
+ &(gc_instr->free_pmc_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_string_header"),
+ &(gc_instr->allocate_string_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_string_header"),
+ &(gc_instr->free_string_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_bufferlike_header"),
+ &(gc_instr->allocate_bufferlike_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_bufferlike_header"),
+ &(gc_instr->free_bufferlike_header));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_pmc_attributes"),
+ &(gc_instr->allocate_pmc_attributes));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_pmc_attributes"),
+ &(gc_instr->free_pmc_attributes));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_string_storage"),
+ &(gc_instr->allocate_string_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "reallocate_string_storage"),
+ &(gc_instr->reallocate_string_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_buffer_storage"),
+ &(gc_instr->allocate_buffer_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "reallocate_buffer_storage"),
+ &(gc_instr->reallocate_buffer_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_fixed_size_storage"),
+ &(gc_instr->allocate_fixed_size_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_fixed_size_storage"),
+ &(gc_instr->free_fixed_size_storage));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_memory_chunk"),
+ &(gc_instr->allocate_memory_chunk));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk"),
+ &(gc_instr->reallocate_memory_chunk));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "allocate_memory_chunk_with_interior_pointers"),
+ &(gc_instr->allocate_memory_chunk_with_interior_pointers));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "reallocate_memory_chunk_with_interior_pointers"),
+ &(gc_instr->reallocate_memory_chunk_with_interior_pointers));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "free_memory_chunk"),
+ &(gc_instr->free_memory_chunk));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "block_mark"),
+ &(gc_instr->block_mark));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "unblock_mark"),
+ &(gc_instr->unblock_mark));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "block_sweep"),
+ &(gc_instr->block_sweep));
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "unblock_sweep"),
+ &(gc_instr->unblock_sweep));
+
+
/* END gc mappings */
}
Modified: branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc
==============================================================================
--- branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Sat Jul 10 15:54:19 2010 (r48065)
+++ branches/gsoc_instrument/src/dynpmc/instrumentvtable.pmc Sat Jul 10 16:53:15 2010 (r48066)
@@ -13,6 +13,7 @@
=head2 Methods
+=over 4
=cut
@@ -289,6 +290,432 @@
*instr = orig;
}
+/*
+
+=item C<PMC* get_hook_list(STRING *name)>
+
+Returns a ResizableStringArray PMC filled with
+the names of the gc entries to instrument.
+
+=cut
+
+*/
+
+ METHOD get_hook_list(STRING *name) {
+ PMC *list;
+
+ list = Parrot_pmc_new(INTERP, enum_class_ResizableStringArray);
+
+ /* BEGIN vtable groupings */
+ if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "exists"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "exists_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "exists_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "exists_keyed_str"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "fetch"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_integer_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_integer_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_integer_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_number_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_number_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_number_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_string_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_string_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_string_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pmc_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pmc_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pmc_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pointer_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pointer_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_pointer_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_integer_native"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_integer_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_integer_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_integer_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_number_native"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_number_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_number_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_number_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_string_native"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "assign_string_native"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_string_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_string_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_string_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_bool"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "assign_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pmc_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pmc_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pmc_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pointer"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pointer_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pointer_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_pointer_keyed_str"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "string"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "concatenate"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "concatenate_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_concatenate"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_concatenate_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "repeat"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "repeat_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_repeat"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_repeat_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "substr"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "substr_str"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "math"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "subtract"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "subtract_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "subtract_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "multiply"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "multiply_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "multiply_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "floor_divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "floor_divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "floor_divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "modulus"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "modulus_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "modulus_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "absolute"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "neg"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "main"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "defined_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "defined_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "defined_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "delete_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "delete_keyed_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "delete_keyed_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "invoke"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "can"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "does_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "does"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "isa_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "isa"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_attr_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "get_attr_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_attr_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_attr_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_parent"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_parent"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_role"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_role"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_attribute"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_attribute"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_method"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_method"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_vtable_override"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_vtable_override"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "inspect_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "freeze"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "thaw"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "thawfinish"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "visit"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "init_int"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "fetchsize"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "push_integer"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "push_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "push_string"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "push_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unshift_integer"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unshift_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unshift_string"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "unshift_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "splice"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "cmp"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "is_equal"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "is_equal_num"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "is_equal_string"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "is_same"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "cmp"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "cmp_num"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "cmp_string"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "cmp_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "logical_or"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "logical_and"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "logical_xor"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "logical_not"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "core"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "init_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "instantiate"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "morph"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "getprop"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "setprop"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "delprop"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "clone_pmc"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "find_method"));
+ }
+ else if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "write"))) {
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "morph"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_add_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_subtract_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_multiply_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_floor_divide_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_modulus_float"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_concatenate"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_concatenate_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_repeat"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "i_repeat_int"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_attr_str"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "set_attr_keyed"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_parent"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_parent"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_role"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_role"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_attribute"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_attribute"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_method"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_method"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "add_vtable_override"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "remove_vtable_override"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "thaw"));
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "thawfinish"));
+ }
+
+ /* END vtable groupings */
+ else {
+ /* Ensure that name is the name of a hook before pushing it in. */
+ size_t *check;
+ check = (size_t *) parrot_hash_get(INTERP, Instrument_Vtable_Stubs, name);
+ if (check == NULL) {
+ Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
+ "Unknown GC function: %Ss", name);
+ }
+
+ VTABLE_push_string(INTERP, list, name);
+ }
+
+ RETURN(PMC *list);
+ }
+
}
/*
@@ -1259,6 +1686,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1267,7 +1696,14 @@
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, "init_pmc"));
@@ -1280,6 +1716,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1289,7 +1727,14 @@
ret = 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, "instantiate"));
@@ -1302,6 +1747,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1310,7 +1757,14 @@
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, "morph"));
@@ -1323,6 +1777,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1332,7 +1788,16 @@
ret = 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, "getprop"));
@@ -1345,6 +1810,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1353,7 +1820,17 @@
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, "setprop"));
@@ -1366,6 +1843,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1374,7 +1853,16 @@
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, "delprop"));
@@ -1387,6 +1875,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1396,7 +1886,14 @@
ret = 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, "clone_pmc"));
@@ -1409,6 +1906,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1418,7 +1917,16 @@
ret = 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, "find_method"));
@@ -1431,6 +1939,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1440,7 +1950,14 @@
ret = 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, "get_integer_keyed"));
@@ -1453,6 +1970,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1462,7 +1981,16 @@
ret = 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, "get_integer_keyed_int"));
@@ -1475,6 +2003,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1484,7 +2014,16 @@
ret = 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, "get_integer_keyed_str"));
@@ -1497,6 +2036,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1506,7 +2047,14 @@
ret = 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, "get_number_keyed"));
@@ -1519,6 +2067,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1528,7 +2078,16 @@
ret = orig_vtable->get_number_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, "get_number_keyed_int"));
@@ -1541,6 +2100,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1550,7 +2111,16 @@
ret = orig_vtable->get_number_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, "get_number_keyed_str"));
@@ -1563,6 +2133,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1572,7 +2144,14 @@
ret = orig_vtable->get_string_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, "get_string_keyed"));
@@ -1585,6 +2164,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1594,7 +2175,16 @@
ret = orig_vtable->get_string_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, "get_string_keyed_int"));
@@ -1607,6 +2197,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1616,7 +2208,16 @@
ret = orig_vtable->get_string_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, "get_string_keyed_str"));
@@ -1629,6 +2230,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1638,7 +2241,14 @@
ret = orig_vtable->get_pmc_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, "get_pmc_keyed"));
@@ -1651,6 +2261,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1660,7 +2272,16 @@
ret = orig_vtable->get_pmc_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, "get_pmc_keyed_int"));
@@ -1673,6 +2294,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1682,7 +2305,16 @@
ret = orig_vtable->get_pmc_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, "get_pmc_keyed_str"));
@@ -1695,6 +2327,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1704,7 +2338,14 @@
ret = orig_vtable->get_pointer_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, "get_pointer_keyed"));
@@ -1717,6 +2358,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1726,7 +2369,16 @@
ret = orig_vtable->get_pointer_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, "get_pointer_keyed_int"));
@@ -1739,6 +2391,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -1748,7 +2402,16 @@
ret = orig_vtable->get_pointer_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, "get_pointer_keyed_str"));
@@ -1761,6 +2424,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1769,7 +2434,16 @@
orig_vtable->set_integer_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);
+ 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, "set_integer_native"));
@@ -1782,6 +2456,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1790,7 +2466,17 @@
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, 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, "set_integer_keyed"));
@@ -1803,6 +2489,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1811,7 +2499,19 @@
orig_vtable->set_integer_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);
+ 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, "set_integer_keyed_int"));
@@ -1824,6 +2524,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1832,7 +2534,19 @@
orig_vtable->set_integer_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);
+ 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, "set_integer_keyed_str"));
@@ -1845,6 +2559,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1853,7 +2569,16 @@
orig_vtable->set_number_native(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, "set_number_native"));
@@ -1866,6 +2591,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1874,7 +2601,17 @@
orig_vtable->set_number_keyed(interp, pmc, key, 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);
+
+
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, "set_number_keyed"));
@@ -1887,6 +2624,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1895,7 +2634,19 @@
orig_vtable->set_number_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_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, "set_number_keyed_int"));
@@ -1908,6 +2659,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1916,7 +2669,19 @@
orig_vtable->set_number_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_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, "set_number_keyed_str"));
@@ -1929,6 +2694,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1937,7 +2704,16 @@
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, 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, "set_string_native"));
@@ -1950,6 +2726,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1958,7 +2736,16 @@
orig_vtable->assign_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, 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, "assign_string_native"));
@@ -1971,6 +2758,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -1979,7 +2768,17 @@
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_String);
+ VTABLE_set_string_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, "set_string_keyed"));
@@ -1992,6 +2791,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2000,7 +2801,19 @@
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_String);
+ VTABLE_set_string_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, "set_string_keyed_int"));
@@ -2013,6 +2826,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2021,7 +2836,19 @@
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_String);
+ VTABLE_set_string_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, "set_string_keyed_str"));
@@ -2034,6 +2861,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2042,7 +2871,16 @@
orig_vtable->set_bool(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "set_bool"));
@@ -2055,6 +2893,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2063,7 +2903,14 @@
orig_vtable->set_pmc(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "set_pmc"));
@@ -2076,6 +2923,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2084,7 +2933,14 @@
orig_vtable->assign_pmc(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "assign_pmc"));
@@ -2097,6 +2953,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2105,7 +2963,15 @@
orig_vtable->set_pmc_keyed(interp, pmc, key, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "set_pmc_keyed"));
@@ -2118,6 +2984,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2126,7 +2994,17 @@
orig_vtable->set_pmc_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);
+ 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, "set_pmc_keyed_int"));
@@ -2139,6 +3017,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2147,7 +3027,17 @@
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, 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, "set_pmc_keyed_str"));
@@ -2160,6 +3050,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2168,7 +3060,16 @@
orig_vtable->set_pointer(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(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, "set_pointer"));
@@ -2181,6 +3082,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2189,7 +3092,17 @@
orig_vtable->set_pointer_keyed(interp, pmc, key, 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);
+ 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, "set_pointer_keyed"));
@@ -2202,6 +3115,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2210,7 +3125,19 @@
orig_vtable->set_pointer_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_Pointer);
+ VTABLE_set_pointer(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, "set_pointer_keyed_int"));
@@ -2223,6 +3150,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2231,7 +3160,19 @@
orig_vtable->set_pointer_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_Pointer);
+ VTABLE_set_pointer(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, "set_pointer_keyed_str"));
@@ -2244,6 +3185,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2252,7 +3195,16 @@
orig_vtable->push_integer(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "push_integer"));
@@ -2265,6 +3217,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2273,7 +3227,16 @@
orig_vtable->push_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, "push_float"));
@@ -2286,6 +3249,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2294,7 +3259,16 @@
orig_vtable->push_string(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "push_string"));
@@ -2307,6 +3281,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2315,7 +3291,14 @@
orig_vtable->push_pmc(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "push_pmc"));
@@ -2328,6 +3311,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2336,7 +3321,16 @@
orig_vtable->unshift_integer(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "unshift_integer"));
@@ -2349,6 +3343,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2357,7 +3353,16 @@
orig_vtable->unshift_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, "unshift_float"));
@@ -2370,6 +3375,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2378,7 +3385,16 @@
orig_vtable->unshift_string(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "unshift_string"));
@@ -2391,6 +3407,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2399,7 +3417,14 @@
orig_vtable->unshift_pmc(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "unshift_pmc"));
@@ -2412,6 +3437,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2420,7 +3447,20 @@
orig_vtable->splice(interp, pmc, value, offset, count);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, offset);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, count);
+ 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, "splice"));
@@ -2433,6 +3473,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2442,7 +3484,15 @@
ret = orig_vtable->add(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "add"));
@@ -2455,6 +3505,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2464,7 +3516,17 @@
ret = orig_vtable->add_int(interp, pmc, value, dest);
+ 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);
+ 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, "add_int"));
@@ -2477,6 +3539,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2486,7 +3550,17 @@
ret = orig_vtable->add_float(interp, pmc, value, dest);
+ 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);
+ 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, "add_float"));
@@ -2499,6 +3573,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2507,7 +3583,14 @@
orig_vtable->i_add(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_add"));
@@ -2520,6 +3603,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2528,7 +3613,16 @@
orig_vtable->i_add_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_add_int"));
@@ -2541,6 +3635,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2549,7 +3645,16 @@
orig_vtable->i_add_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, "i_add_float"));
@@ -2562,6 +3667,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2571,7 +3678,15 @@
ret = orig_vtable->subtract(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "subtract"));
@@ -2584,6 +3699,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2593,7 +3710,17 @@
ret = orig_vtable->subtract_int(interp, pmc, value, dest);
+ 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);
+ 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, "subtract_int"));
@@ -2606,6 +3733,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2615,7 +3744,17 @@
ret = orig_vtable->subtract_float(interp, pmc, value, dest);
+ 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);
+ 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, "subtract_float"));
@@ -2628,6 +3767,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2636,7 +3777,14 @@
orig_vtable->i_subtract(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_subtract"));
@@ -2649,6 +3797,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2657,7 +3807,16 @@
orig_vtable->i_subtract_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_subtract_int"));
@@ -2670,6 +3829,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2678,7 +3839,16 @@
orig_vtable->i_subtract_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, "i_subtract_float"));
@@ -2691,6 +3861,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2700,7 +3872,15 @@
ret = orig_vtable->multiply(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "multiply"));
@@ -2713,6 +3893,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2722,7 +3904,17 @@
ret = orig_vtable->multiply_int(interp, pmc, value, dest);
+ 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);
+ 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, "multiply_int"));
@@ -2735,6 +3927,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2744,7 +3938,17 @@
ret = orig_vtable->multiply_float(interp, pmc, value, dest);
+ 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);
+ 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, "multiply_float"));
@@ -2757,6 +3961,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2765,7 +3971,14 @@
orig_vtable->i_multiply(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_multiply"));
@@ -2778,6 +3991,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2786,7 +4001,16 @@
orig_vtable->i_multiply_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_multiply_int"));
@@ -2799,6 +4023,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2807,7 +4033,16 @@
orig_vtable->i_multiply_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, "i_multiply_float"));
@@ -2820,6 +4055,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2829,7 +4066,15 @@
ret = orig_vtable->divide(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "divide"));
@@ -2842,6 +4087,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2851,7 +4098,17 @@
ret = orig_vtable->divide_int(interp, pmc, value, dest);
+ 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);
+ 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, "divide_int"));
@@ -2864,6 +4121,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2873,7 +4132,17 @@
ret = orig_vtable->divide_float(interp, pmc, value, dest);
+ 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);
+ 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, "divide_float"));
@@ -2886,6 +4155,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2894,7 +4165,14 @@
orig_vtable->i_divide(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_divide"));
@@ -2907,6 +4185,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2915,7 +4195,16 @@
orig_vtable->i_divide_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_divide_int"));
@@ -2928,6 +4217,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -2936,7 +4227,16 @@
orig_vtable->i_divide_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, "i_divide_float"));
@@ -2949,6 +4249,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2958,7 +4260,15 @@
ret = orig_vtable->floor_divide(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "floor_divide"));
@@ -2971,6 +4281,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -2980,7 +4292,17 @@
ret = orig_vtable->floor_divide_int(interp, pmc, value, dest);
+ 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);
+ 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, "floor_divide_int"));
@@ -2993,6 +4315,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3002,7 +4326,17 @@
ret = orig_vtable->floor_divide_float(interp, pmc, value, dest);
+ 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);
+ 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, "floor_divide_float"));
@@ -3015,6 +4349,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3023,7 +4359,14 @@
orig_vtable->i_floor_divide(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_floor_divide"));
@@ -3036,6 +4379,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3044,7 +4389,16 @@
orig_vtable->i_floor_divide_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_floor_divide_int"));
@@ -3057,6 +4411,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3065,7 +4421,16 @@
orig_vtable->i_floor_divide_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, "i_floor_divide_float"));
@@ -3078,6 +4443,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3087,7 +4454,15 @@
ret = orig_vtable->modulus(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "modulus"));
@@ -3100,6 +4475,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3109,7 +4486,17 @@
ret = orig_vtable->modulus_int(interp, pmc, value, dest);
+ 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);
+ 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, "modulus_int"));
@@ -3122,6 +4509,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3131,7 +4520,17 @@
ret = orig_vtable->modulus_float(interp, pmc, value, dest);
+ 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);
+ 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, "modulus_float"));
@@ -3144,6 +4543,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3152,7 +4553,14 @@
orig_vtable->i_modulus(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_modulus"));
@@ -3165,6 +4573,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3173,7 +4583,16 @@
orig_vtable->i_modulus_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_modulus_int"));
@@ -3186,6 +4605,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3194,7 +4615,16 @@
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, "i_modulus_float"));
@@ -3207,6 +4637,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3216,7 +4648,14 @@
ret = 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, "absolute"));
@@ -3229,6 +4668,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3238,7 +4679,14 @@
ret = orig_vtable->neg(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, "neg"));
@@ -3251,6 +4699,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3260,7 +4710,14 @@
ret = orig_vtable->is_equal(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "is_equal"));
@@ -3273,6 +4730,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3282,7 +4741,14 @@
ret = orig_vtable->is_equal_num(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "is_equal_num"));
@@ -3295,6 +4761,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3304,7 +4772,14 @@
ret = orig_vtable->is_equal_string(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "is_equal_string"));
@@ -3317,6 +4792,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3326,7 +4803,14 @@
ret = orig_vtable->is_same(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "is_same"));
@@ -3339,6 +4823,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3348,7 +4834,14 @@
ret = orig_vtable->cmp(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "cmp"));
@@ -3361,6 +4854,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3370,7 +4865,14 @@
ret = orig_vtable->cmp_num(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "cmp_num"));
@@ -3383,6 +4885,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3392,7 +4896,14 @@
ret = orig_vtable->cmp_string(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "cmp_string"));
@@ -3405,6 +4916,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3414,7 +4927,14 @@
ret = orig_vtable->cmp_pmc(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "cmp_pmc"));
@@ -3427,6 +4947,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3436,7 +4958,15 @@
ret = orig_vtable->logical_or(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "logical_or"));
@@ -3449,6 +4979,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3458,7 +4990,15 @@
ret = orig_vtable->logical_and(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "logical_and"));
@@ -3471,6 +5011,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3480,7 +5022,15 @@
ret = orig_vtable->logical_xor(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "logical_xor"));
@@ -3493,6 +5043,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3502,7 +5054,14 @@
ret = orig_vtable->logical_not(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, "logical_not"));
@@ -3515,6 +5074,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3524,7 +5085,15 @@
ret = orig_vtable->concatenate(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "concatenate"));
@@ -3537,6 +5106,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3546,7 +5117,17 @@
ret = orig_vtable->concatenate_str(interp, pmc, value, dest);
+ 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);
+ 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, "concatenate_str"));
@@ -3559,6 +5140,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3567,7 +5150,14 @@
orig_vtable->i_concatenate(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_concatenate"));
@@ -3580,6 +5170,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3588,7 +5180,16 @@
orig_vtable->i_concatenate_str(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_concatenate_str"));
@@ -3601,6 +5202,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3610,7 +5213,15 @@
ret = orig_vtable->repeat(interp, pmc, value, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, value);
+ 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, "repeat"));
@@ -3623,6 +5234,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3632,7 +5245,17 @@
ret = orig_vtable->repeat_int(interp, pmc, value, dest);
+ 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);
+ 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, "repeat_int"));
@@ -3645,6 +5268,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3653,7 +5278,14 @@
orig_vtable->i_repeat(interp, pmc, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ 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, "i_repeat"));
@@ -3666,6 +5298,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3674,7 +5308,16 @@
orig_vtable->i_repeat_int(interp, pmc, value);
+ 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);
+ VTABLE_set_pmc_keyed_str(supervisor, data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
raise_vtable_event(supervisor, interp, pmc, data,
CONST_STRING(supervisor, "i_repeat_int"));
@@ -3687,6 +5330,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3695,7 +5340,20 @@
orig_vtable->substr(interp, pmc, offset, length, dest);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, offset);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, length);
+ VTABLE_push_pmc(supervisor, params, temp);
+ 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, "substr"));
@@ -3708,6 +5366,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3717,7 +5377,19 @@
ret = orig_vtable->substr_str(interp, pmc, offset, length);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, offset);
+ VTABLE_push_pmc(supervisor, params, temp);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, length);
+ 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, "substr_str"));
@@ -3730,6 +5402,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3739,7 +5413,14 @@
ret = orig_vtable->exists_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, "exists_keyed"));
@@ -3752,6 +5433,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3761,7 +5444,16 @@
ret = orig_vtable->exists_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, "exists_keyed_int"));
@@ -3774,6 +5466,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3783,7 +5477,16 @@
ret = orig_vtable->exists_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, "exists_keyed_str"));
@@ -3796,6 +5499,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3805,7 +5510,14 @@
ret = orig_vtable->defined_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, "defined_keyed"));
@@ -3818,6 +5530,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3827,7 +5541,16 @@
ret = orig_vtable->defined_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, "defined_keyed_int"));
@@ -3840,6 +5563,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3849,7 +5574,16 @@
ret = orig_vtable->defined_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, "defined_keyed_str"));
@@ -3862,6 +5596,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3870,7 +5606,14 @@
orig_vtable->delete_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, "delete_keyed"));
@@ -3883,6 +5626,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3891,7 +5636,16 @@
orig_vtable->delete_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, "delete_keyed_int"));
@@ -3904,6 +5658,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3912,7 +5668,16 @@
orig_vtable->delete_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, "delete_keyed_str"));
@@ -3925,6 +5690,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
opcode_t* ret;
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -3934,7 +5701,16 @@
ret = orig_vtable->invoke(interp, pmc, next);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, next);
+ 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, "invoke"));
@@ -3947,6 +5723,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3956,7 +5734,16 @@
ret = orig_vtable->can(interp, pmc, method);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, method);
+ 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, "can"));
@@ -3969,6 +5756,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -3978,7 +5767,14 @@
ret = orig_vtable->does_pmc(interp, pmc, role);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, role);
+
+
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, "does_pmc"));
@@ -3991,6 +5787,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4000,7 +5798,16 @@
ret = orig_vtable->does(interp, pmc, role);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, role);
+ 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, "does"));
@@ -4013,6 +5820,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4022,7 +5831,14 @@
ret = orig_vtable->isa_pmc(interp, pmc, _class);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, _class);
+
+
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, "isa_pmc"));
@@ -4035,6 +5851,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4044,7 +5862,16 @@
ret = orig_vtable->isa(interp, pmc, _class);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, _class);
+ 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, "isa"));
@@ -4057,6 +5884,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4066,7 +5895,16 @@
ret = orig_vtable->get_attr_str(interp, pmc, idx);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, idx);
+ 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, "get_attr_str"));
@@ -4079,6 +5917,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4088,7 +5928,17 @@
ret = orig_vtable->get_attr_keyed(interp, pmc, key, idx);
+ 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, idx);
+ 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, "get_attr_keyed"));
@@ -4101,6 +5951,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4109,7 +5961,17 @@
orig_vtable->set_attr_str(interp, pmc, idx, value);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, idx);
+ 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, "set_attr_str"));
@@ -4122,6 +5984,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4130,7 +5994,18 @@
orig_vtable->set_attr_keyed(interp, pmc, key, idx, 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, idx);
+ 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, "set_attr_keyed"));
@@ -4143,6 +6018,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4151,7 +6028,14 @@
orig_vtable->add_parent(interp, pmc, parent);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, parent);
+
+
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, "add_parent"));
@@ -4164,6 +6048,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4172,7 +6058,14 @@
orig_vtable->remove_parent(interp, pmc, parent);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, parent);
+
+
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, "remove_parent"));
@@ -4185,6 +6078,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4193,7 +6088,14 @@
orig_vtable->add_role(interp, pmc, role);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, role);
+
+
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, "add_role"));
@@ -4206,6 +6108,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4214,7 +6118,14 @@
orig_vtable->remove_role(interp, pmc, role);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, role);
+
+
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, "remove_role"));
@@ -4227,6 +6138,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4235,7 +6148,17 @@
orig_vtable->add_attribute(interp, pmc, name, type);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, name);
+ VTABLE_push_pmc(supervisor, params, temp);
+ 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, "add_attribute"));
@@ -4248,6 +6171,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4256,7 +6181,16 @@
orig_vtable->remove_attribute(interp, pmc, name);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, 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, "remove_attribute"));
@@ -4269,6 +6203,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4277,7 +6213,17 @@
orig_vtable->add_method(interp, pmc, method_name, sub_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);
+ VTABLE_push_pmc(supervisor, params, sub_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, "add_method"));
@@ -4290,6 +6236,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4298,7 +6246,16 @@
orig_vtable->remove_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, "remove_method"));
@@ -4311,6 +6268,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4319,7 +6278,17 @@
orig_vtable->add_vtable_override(interp, pmc, vtable_name, sub_pmc);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, vtable_name);
+ VTABLE_push_pmc(supervisor, params, temp);
+ VTABLE_push_pmc(supervisor, params, sub_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, "add_vtable_override"));
@@ -4332,6 +6301,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4340,7 +6311,16 @@
orig_vtable->remove_vtable_override(interp, pmc, vtable_name);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, vtable_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, "remove_vtable_override"));
@@ -4353,6 +6333,8 @@
PMC *instr_vt, *data;
_vtable *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, Instrument_Vtable_Entries, pmc->vtable);
@@ -4362,7 +6344,16 @@
ret = orig_vtable->inspect_str(interp, pmc, what);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, what);
+ 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, "inspect_str"));
@@ -4375,6 +6366,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4383,7 +6376,14 @@
orig_vtable->freeze(interp, pmc, info);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, info);
+
+
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, "freeze"));
@@ -4396,6 +6396,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4404,7 +6406,14 @@
orig_vtable->thaw(interp, pmc, info);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, info);
+
+
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, "thaw"));
@@ -4417,6 +6426,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4425,7 +6436,14 @@
orig_vtable->thawfinish(interp, pmc, info);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, info);
+
+
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, "thawfinish"));
@@ -4438,6 +6456,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4446,7 +6466,14 @@
orig_vtable->visit(interp, pmc, info);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ VTABLE_push_pmc(supervisor, params, info);
+
+
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, "visit"));
@@ -4459,6 +6486,8 @@
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -4467,7 +6496,16 @@
orig_vtable->init_int(interp, pmc, initializer);
+ VTABLE_push_pmc(supervisor, params, pmc);
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, initializer);
+ 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, "init_int"));
@@ -4479,6 +6517,16 @@
/* END vtable stubs */
/*
+
+=back
+
+=head1 SEE ALSO
+
+=cut
+
+*/
+
+/*
* Local variables:
* c-file-style: "parrot"
* End:
Added: branches/gsoc_instrument/tools/build/gen_gc_stubs.pl
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ branches/gsoc_instrument/tools/build/gen_gc_stubs.pl Sat Jul 10 16:53:15 2010 (r48066)
@@ -0,0 +1,341 @@
+#! perl
+# $Id$
+
+# Copyright (C) 2010, Parrot Foundation.
+
+=head1 NAME
+
+tools/build/gen_gc_stubs.pl
+
+=head1 DESCRIPTION
+
+Generate GC stubs for use in InstrumentGC.
+
+Read the GC_Subsytem struct from src/gc/gc_private.h
+and from there, generate the prototype and the stub
+functions before putting in the the respective placeholders
+in src/dynpmc/instrumentgc.pmc.
+
+=cut
+
+use warnings;
+use strict;
+
+use IO::File;
+use Fcntl qw(:DEFAULT :flock);
+
+my $dynpmc_file = 'src/dynpmc/instrumentgc.pmc';
+my $source_file = 'src/gc/gc_private.h';
+
+my $dynpmc_fh = IO::File->new($dynpmc_file, O_RDWR | O_CREAT);
+my $source_fh = IO::File->new($source_file, O_RDWR | O_CREAT);
+
+die "Could not open $dynpmc_file!" if !$dynpmc_fh;
+die "Could not open $source_file!" if !$source_fh;
+
+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);
+
+# Read the whole file.
+my $contents = join('', map { chomp;$_; } <$source_fh>);
+
+# Extract struct GC_Subsystem.
+$contents =~ /typedef struct GC_Subsystem {(.*)} GC_Subsystem;/;
+my $subsystem = $1;
+
+# Remove comments.
+$subsystem =~ s/\/\*.*?\*\///g;
+foreach (split /\s*;\s*/, $subsystem) {
+ chomp;
+
+ if(/^\s*(.*)\s*\(\*(.+)\)\s*\((.*)\)$/) {
+ my @data = ($1, $2, $3);
+ $data[2] = fix_params($data[2]);
+
+ # Ignore is_blocked_mark, is_blocked_sweep, get_gc_info.
+ next if $data[1] eq 'is_blocked_mark'
+ || $data[1] eq 'is_blocked_sweep'
+ || $data[1] eq 'get_gc_info';
+
+ # Deduce the group.
+ my @tokens = split(/_/, $data[1]);
+ if($tokens[0] eq "allocate") {
+ push(@{$groups{'allocate'}}, $data[1]);
+ push @data, 'allocate';
+ }
+ elsif($tokens[0] eq "free") {
+ push(@{$groups{'free'}}, $data[1]);
+ push @data, 'free';
+ }
+ elsif($tokens[0] eq "reallocate") {
+ push(@{$groups{'reallocate'}}, $data[1]);
+ push @data, 'reallocate';
+ }
+ else {
+ push(@{$groups{'administration'}}, $data[1]);
+ push @data, 'administration';
+ }
+
+ push @prototypes, gen_prototype(@data);
+ push @stubs, gen_stub(@data);
+
+ push @entries, $data[1];
+ }
+}
+
+my %placeholders = (
+ 'gc prototypes' => join('', @prototypes),
+ 'gc stubs' => join('', @stubs),
+ 'gc mappings' => gen_mapping_string(@entries),
+ 'gc groupings' => gen_grouping_string(\%groups, \@entries)
+);
+
+my @contents = ();
+my($ignore, $matching_string) = (0, undef);
+while(<$dynpmc_fh>) {
+ chomp;
+
+ # If we are supposed to ignore, check for end of placeholder
+ # before ignoring.
+ if($ignore) {
+ if(m/^\s*\/\* END (.*) \*\/$/) {
+ if($1 eq $matching_string) {
+ push @contents, $_;
+ $ignore = 0;
+ }
+ }
+ next;
+ }
+
+ # Push into @contents and check if we have the beginnings of a placeholder.
+ push @contents, $_;
+ if(m/^\s*\/\* BEGIN (.*) \*\/$/) {
+ $matching_string = $1;
+ $ignore = 1;
+ push @contents, $placeholders{$matching_string};
+ }
+}
+
+flock($dynpmc_fh, LOCK_UN) or die "Cannot unlock $dynpmc_file!";
+flock($source_fh, LOCK_UN) or die "Cannot unlock $source_file!";
+
+$dynpmc_fh->close();
+$source_fh->close();
+
+# Write to the file.
+$dynpmc_fh = IO::File->new($dynpmc_file, O_WRONLY | O_CREAT | O_TRUNC)
+or die "Could not write to file $dynpmc_file!";
+
+flock($dynpmc_fh, LOCK_EX);
+print $dynpmc_fh join("\n", @contents)."\n";
+flock($dynpmc_fh, LOCK_UN);
+
+$dynpmc_fh->close();
+
+sub gen_prototype {
+ my @data = @_;
+
+ return <<PROTOTYPE;
+$data[0] stub_$data[1]($data[2]);
+PROTOTYPE
+}
+
+sub gen_stub {
+ my($ret, $name, $params, $group) = @_;
+
+ # Process the parameter list.
+ my @param_types = ();
+ my @param_names = ();
+ my $param;
+ my $param_count = 0;
+ foreach $param (split /\s*,\s*/, $params) {
+ $param_count++;
+ chomp $param;
+
+ if($param eq '') { next; }
+
+ # First parameter is always an interp.
+ if($param eq 'PARROT_INTERP') {
+ push @param_types, 'Parrot_Interp';
+ push @param_names, 'interp';
+ next;
+ }
+ elsif($param_count == 1) {
+ my @tokens = split(/\s+/, $param);
+ push @param_types, $tokens[0];
+ push @param_names, 'interp';
+ next;
+ }
+
+ # Some parameters have more than 2 tokens,
+ # eg struct a* b
+ my @tokens = split(/\s+/, $param);
+ if(scalar(@tokens) > 2) {
+ push @param_names, pop(@tokens);
+ push @param_types, join(' ', @tokens);
+ }
+ else {
+ push @param_types, $tokens[0];
+ push @param_names, $tokens[1];
+ }
+ }
+
+ my $param_list_flat = (scalar(@param_names)) ? join(', ', @param_names) : '';
+ $param_count = 0;
+ $params = join(', ', map { $_.' '.$param_names[$param_count++] } @param_types);
+
+ my($ret_dec, $ret_ret, $ret_last) = ('','','');
+ if ($ret !~ /^\s*void\s*$/) {
+ $ret_dec = ' '.$ret.' ret;'."\n";
+ $ret_ret = ' ret =';
+ $ret_last = ' ret';
+ }
+
+ # Prepare to pass the parameter list to instrument.
+ my $instr_params = '';
+ for(my $i = 1; $i < @param_types; $i++) {
+ if($param_types[$i] eq 'size_t' || $param_types[$i] eq 'UINTVAL') {
+ $instr_params .= <<INTEGER;
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+INTEGER
+ }
+ else {
+ # Assume pointer.
+ $instr_params .= <<POINTER;
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+POINTER
+ }
+ }
+
+ return <<STUB;
+$ret stub_$name($params) {
+ PMC *instr_gc = ((InstrumentGC_Subsystem *) interp->gc_sys)->instrument_gc;
+ Parrot_Interp supervisor = ((InstrumentGC_Subsystem *) interp->gc_sys)->supervisor;
+ GC_Subsystem *gc_orig;
+ PMC *event_data;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(supervisor, enum_class_ResizablePMCArray);
+$ret_dec
+ GETATTR_InstrumentGC_gc_original(supervisor, instr_gc, gc_orig);
+ $ret_ret gc_orig->$name($param_list_flat);
+
+$instr_params
+ event_data = Parrot_pmc_new(supervisor, enum_class_Hash);
+ VTABLE_set_string_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "type"),
+ CONST_STRING(supervisor, "$name"));
+ VTABLE_set_pmc_keyed_str(supervisor, event_data,
+ CONST_STRING(supervisor, "parameters"),
+ params);
+
+ raise_gc_event(supervisor, interp, CONST_STRING(supervisor, "$group"), event_data);
+
+ return$ret_last;
+}
+
+STUB
+}
+
+sub gen_mapping_string {
+ my @entries = @_;
+
+ my($name, @orig, @instr, @stubs);
+ foreach $name (@entries) {
+ push @stubs, <<STUBS;
+ parrot_hash_put(interp, instr_hash,
+ CONST_STRING(interp, "$name"),
+ stub_$name);
+STUBS
+ push @orig, <<ORIG;
+ parrot_hash_put(interp, orig_hash,
+ CONST_STRING(interp, "$name"),
+ gc_orig->$name);
+ORIG
+ push @instr, <<INSTR;
+ parrot_hash_put(interp, entry_hash,
+ CONST_STRING(interp, "$name"),
+ &(gc_instr->$name));
+INSTR
+ }
+
+ return <<MAPPINGS;
+ /* Build the pointer hash to the stubs. */
+ @stubs
+
+ /* Build the pointer hash to the original. */
+ @orig
+
+ /* Build the pointer hash for name to InstrumentGC_Subsystem entry. */
+ @instr
+MAPPINGS
+}
+
+sub gen_grouping_string {
+ my($groups, $entries) = @_;
+ my($group, $entry);
+
+ my @groups;
+ foreach $group (keys %{$groups}) {
+ my @list = @{$groups->{$group}};
+
+ my $ret .= <<PRE;
+if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "$group"))) {
+PRE
+
+ foreach $entry (@list) {
+ $ret .= <<ENTRY;
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "$entry"));
+ENTRY
+ }
+
+ $ret .= <<END;
+ }
+END
+
+ push @groups, $ret;
+ }
+
+ return ' '.join(' else ', @groups);
+}
+
+sub fix_params {
+ my $params = shift;
+ my @param_list;
+ my $param;
+ my $stub_count = 1;
+
+ foreach $param (split(/\s*,\s*/, $params)) {
+ # Fix void * to void* and similar.
+ $param =~ s/(.*) \*/$1\* /;
+
+ # Remove annotations, eg ARGMOD(Buffer* buf)
+ $param =~ s/\w+\((.*)\)/$1/;
+
+ # Add stub parameter names for unnamed parameters.
+ # Eg, Buffer*, struct Fixed_Size_Pool*
+ if($param ne 'PARROT_INTERP') {
+ if($param !~ /^(.+)\s+(\w+)$/) {
+ $param .= " stub_var".$stub_count++;
+ #print $param."\n";
+ }
+ }
+
+ push @param_list, $param;
+ }
+
+ return join(', ', @param_list);
+}
+
+# Local Variables:
+# mode: cperl
+# cperl-indent-level: 4
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4:
Modified: branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl
==============================================================================
--- branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sat Jul 10 15:54:19 2010 (r48065)
+++ branches/gsoc_instrument/tools/build/gen_vtable_stubs.pl Sat Jul 10 16:53:15 2010 (r48066)
@@ -85,7 +85,8 @@
my %placeholders = (
'vtable prototypes' => join('', @prototypes),
'vtable stubs' => join('', @stubs),
- 'vtable mappings' => gen_mapping_string(@entries)
+ 'vtable mappings' => gen_mapping_string(@entries),
+ 'vtable groupings' => gen_grouping_string(\%groups, \@entries)
);
my @contents = ();
@@ -125,7 +126,7 @@
or die "Could not write to file $dynpmc_file!";
flock($dynpmc_fh, LOCK_EX);
-print $dynpmc_fh join("\n", @contents);
+print $dynpmc_fh join("\n", @contents)."\n";
flock($dynpmc_fh, LOCK_UN);
$dynpmc_fh->close();
@@ -170,12 +171,54 @@
$ret_last = ' ret';
}
+ # Prepare to pass the parameter list to instrument.
+ my $instr_params = '';
+ for(my $i = 1; $i < @param_types; $i++) {
+ if($param_types[$i] eq 'size_t' || $param_types[$i] eq 'UINTVAL'
+ || $param_types[$i] eq 'INTVAL') {
+ $instr_params .= <<INTEGER;
+ temp = Parrot_pmc_new(supervisor, enum_class_Integer);
+ VTABLE_set_integer_native(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+INTEGER
+ }
+ elsif($param_types[$i] eq 'FLOATVAL') {
+ $instr_params .= <<FLOAT;
+ temp = Parrot_pmc_new(supervisor, enum_class_Float);
+ VTABLE_set_number_native(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+FLOAT
+ }
+ elsif($param_types[$i] eq 'PMC*') {
+ $instr_params .= <<PMC;
+ VTABLE_push_pmc(supervisor, params, $param_names[$i]);
+PMC
+ }
+ elsif($param_types[$i] eq 'STRING*') {
+ $instr_params .= <<STRING;
+ temp = Parrot_pmc_new(supervisor, enum_class_String);
+ VTABLE_set_string_native(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+STRING
+ }
+ else {
+ # Assume pointer.
+ $instr_params .= <<POINTER;
+ temp = Parrot_pmc_new(supervisor, enum_class_Pointer);
+ VTABLE_set_pointer(supervisor, temp, $param_names[$i]);
+ VTABLE_push_pmc(supervisor, params, temp);
+POINTER
+ }
+ }
+
return <<CODE;
static
$ret stub_$name($params) {
PMC *instr_vt, *data;
_vtable *orig_vtable;
Parrot_Interp supervisor;
+ PMC *temp;
+ PMC *params = Parrot_pmc_new(interp, enum_class_ResizablePMCArray);
$ret_dec
instr_vt = (PMC *) parrot_hash_get(interp, Instrument_Vtable_Entries, pmc->vtable);
@@ -184,7 +227,12 @@
$ret_ret orig_vtable->$name($param_list_flat);
+$instr_params
+
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, "$name"));
@@ -232,3 +280,40 @@
}
MAPPINGS
}
+
+sub gen_grouping_string {
+ my($groups, $entries) = @_;
+ my($group, $entry);
+
+ my @groups;
+ foreach $group (keys %{$groups}) {
+ my @list = @{$groups->{$group}};
+ $group = lc($group);
+
+ my $ret .= <<PRE;
+if (Parrot_str_equal(INTERP, name, CONST_STRING(INTERP, "$group"))) {
+PRE
+
+ foreach $entry (@list) {
+ $ret .= <<ENTRY;
+ VTABLE_push_string(INTERP, list,
+ CONST_STRING(INTERP, "$entry"));
+ENTRY
+ }
+
+ $ret .= <<END;
+ }
+END
+
+ push @groups, $ret;
+ }
+
+ return ' '.join(' else ', @groups);
+}
+
+# Local Variables:
+# mode: cperl
+# cperl-indent-level: 4
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4:
More information about the parrot-commits
mailing list