[WRAPPER] Used RunFunctionFmt for better sign-extend handling (#768)

* [WRAPPER] Used RunFunctionFmt for better sign-extend handling

* [WRAPPER] Fixed some typos

* [WRAPPER] Use L for unsigned long for better portability

* [WRAPPER] More replace from U to L

63 files changed, 1987 insertions, 1987 deletions

diff --git a/src/libtools/sdl1rwops.c b/src/libtools/sdl1rwops.c
index c7349af6..373600f3 100755
--- a/src/libtools/sdl1rwops.c
+++ b/src/libtools/sdl1rwops.c
@@ -72,20 +72,20 @@ EXPORT int32_t my_native_close(SDL1_RWops_t *context)
 }
 EXPORT int32_t my_emulated_seek(SDL1_RWops_t *context, int32_t offset, int32_t whence)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->seek, 3, context->hidden.my.orig, offset, whence);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->seek, "pii", context->hidden.my.orig, offset, whence);
 }
 EXPORT int32_t my_emulated_read(SDL1_RWops_t *context, void *ptr, int32_t size, int32_t maxnum)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->read, 4, context->hidden.my.orig, ptr, size, maxnum);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->read, "ppii", context->hidden.my.orig, ptr, size, maxnum);
 }
 
 EXPORT int32_t my_emulated_write(SDL1_RWops_t *context, const void *ptr, int32_t size, int32_t num)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->write, 4, context->hidden.my.orig, ptr, size, num);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->write, "ppii", context->hidden.my.orig, ptr, size, num);
 }
 EXPORT int32_t my_emulated_close(SDL1_RWops_t *context)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->close, 1, context->hidden.my.orig);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->close, "p", context->hidden.my.orig);
 }
 
 SDL1_RWops_t* AddNativeRW(x64emu_t* emu, SDL1_RWops_t* ops)
@@ -180,4 +180,4 @@ void RWSetType(SDL1_RWops_t* r, int awesome)
 {
     if(r)
         r->type = awesome;  // I like shoot'em up :D
-}
\ No newline at end of file
+}
diff --git a/src/libtools/sdl2rwops.c b/src/libtools/sdl2rwops.c
index 9b18dd8f..9a1f4d07 100755
--- a/src/libtools/sdl2rwops.c
+++ b/src/libtools/sdl2rwops.c
@@ -85,23 +85,23 @@ EXPORT int32_t my2_native_close(SDL2_RWops_t *context)
 }
 EXPORT int64_t my2_emulated_size(SDL2_RWops_t *context)
 {
-    return (int64_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->size, 1, context->hidden.my.orig);
+    return (int64_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->size, "p", context->hidden.my.orig);
 }
 EXPORT int64_t my2_emulated_seek(SDL2_RWops_t *context, int64_t offset, int32_t whence)
 {
-    return (int64_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->seek, 3, context->hidden.my.orig, offset, whence);
+    return (int64_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->seek, "pIi", context->hidden.my.orig, offset, whence);
 }
 EXPORT int32_t my2_emulated_read(SDL2_RWops_t *context, void *ptr, int32_t size, int32_t maxnum)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->read, 4, context->hidden.my.orig, ptr, size, maxnum);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->read, "ppii", context->hidden.my.orig, ptr, size, maxnum);
 }
 EXPORT int32_t my2_emulated_write(SDL2_RWops_t *context, const void *ptr, int32_t size, int32_t num)
 {
-    return (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->write, 4, context->hidden.my.orig, ptr, size, num);
+    return (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->write, "ppii", context->hidden.my.orig, ptr, size, num);
 }
 EXPORT int32_t my2_emulated_close(SDL2_RWops_t *context)
 {
-    int ret = (int32_t)RunFunction(my_context, (uintptr_t)context->hidden.my.orig->close, 1, context->hidden.my.orig);
+    int ret = (int32_t)RunFunctionFmt(my_context, (uintptr_t)context->hidden.my.orig->close, "p", context->hidden.my.orig);
     context->hidden.my.custom_free(context);
     return ret;
 }
@@ -109,12 +109,12 @@ EXPORT int32_t my2_emulated_close(SDL2_RWops_t *context)
 static uintptr_t emulated_sdl2allocrw = 0;
 EXPORT SDL2_RWops_t* my_wrapped_sdl2allocrw()
 {
-    return (SDL2_RWops_t*)RunFunction(my_context, emulated_sdl2allocrw, 0);
+    return (SDL2_RWops_t*)RunFunctionFmt(my_context, emulated_sdl2allocrw, "");
 }
 static uintptr_t emulated_sdl2freerw = 0;
 EXPORT void my_wrapped_sdl2freerw(SDL2_RWops_t* p)
 {
-    RunFunction(my_context, emulated_sdl2freerw, 1, p);
+    RunFunctionFmt(my_context, emulated_sdl2freerw, "p", p);
 }
 
 static void checkSDL2isNative()
@@ -174,7 +174,7 @@ SDL2_RWops_t* RWNativeStart2(x64emu_t* emu, SDL2_RWops_t* ops)
     newrw->type = BOX64RW;
     newrw->hidden.my.orig = ops;
     newrw->hidden.my.custom_free = (sdl2_freerw)emu->context->sdl2freerw;
-   
+
     // create wrapper
     #define GO(A, W) \
     newrw->A = my2_emulated_##A;
@@ -229,4 +229,4 @@ int32_t RWNativeWrite2(SDL2_RWops_t *ops, const void *ptr, int32_t size, int32_t
 int32_t RWNativeClose2(SDL2_RWops_t* ops)
 {
     return ops->close(ops);
-}
\ No newline at end of file
+}
diff --git a/src/tools/gtkclass.c b/src/tools/gtkclass.c
index 22474a2f..e647f7b1 100755
--- a/src/tools/gtkclass.c
+++ b/src/tools/gtkclass.c
@@ -58,12 +58,12 @@ GO(10)	\
 GO(11)	\
 GO(12)
 
-#define WRAPPED(A, NAME, RET, DEF, N, ...)  \
+#define WRAPPED(A, NAME, RET, DEF, FMT, ...)  \
 static uintptr_t my_##NAME##_fct_##A = 0;   \
 static RET my_##NAME##_##A DEF              \
 {                                           \
     printf_log(LOG_DEBUG, "Calling " #NAME "_" #A " wrapper\n");             \
-    return (RET)RunFunction(my_context, my_##NAME##_fct_##A, N, __VA_ARGS__);\
+    return (RET)RunFunctionFmt(my_context, my_##NAME##_fct_##A, FMT, __VA_ARGS__);\
 }
 
 #define FIND(A, NAME) \
@@ -120,29 +120,29 @@ static void autobridge_##NAME##_##A(wrapper_t W, void* fct)         \
         AddAutomaticBridge(thread_get_emu(), my_bridge, W, fct, 0); \
 }
 
-#define WRAPPER(A, NAME, RET, DEF, N, ...)          \
-WRAPPED(0, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(1, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(2, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(3, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(4, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(5, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(6, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
-WRAPPED(7, NAME##_##A, RET, DEF, N, __VA_ARGS__)    \
+#define WRAPPER(A, NAME, RET, DEF, FMT, ...)        \
+WRAPPED(0, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(1, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(2, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(3, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(4, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(5, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(6, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
+WRAPPED(7, NAME##_##A, RET, DEF, FMT, __VA_ARGS__)  \
 FIND(A, NAME)                                       \
 REVERSE(A, NAME)                                    \
 AUTOBRIDGE(A, NAME)
 
 // ----- GObjectClass ------
 // wrapper x64 -> natives of callbacks
-WRAPPER(GObject, constructor, void*, (size_t type, uint32_t n_construct_properties, void* construct_properties), 3, type, n_construct_properties, construct_properties);
-WRAPPER(GObject, set_property, void, (void* object, uint32_t property_id, void* value, void* pspec), 4, object, property_id, value, pspec);
-WRAPPER(GObject, get_property, void, (void* object, uint32_t property_id, void* value, void* pspec), 4, object, property_id, value, pspec);
-WRAPPER(GObject, dispose, void, (void* object), 1, object);
-WRAPPER(GObject, finalize, void, (void* object), 1, object);
-WRAPPER(GObject, dispatch_properties_changed, void*, (size_t type, uint32_t n_pspecs, void* pspecs), 3, type, n_pspecs, pspecs);
-WRAPPER(GObject, notify, void*, (size_t type, void* pspecs), 2, type, pspecs);
-WRAPPER(GObject, constructed, void, (void* object), 1, object);
+WRAPPER(GObject, constructor, void*, (size_t type, uint32_t n_construct_properties, void* construct_properties), "Lup", type, n_construct_properties, construct_properties);
+WRAPPER(GObject, set_property, void, (void* object, uint32_t property_id, void* value, void* pspec), "pupp", object, property_id, value, pspec);
+WRAPPER(GObject, get_property, void, (void* object, uint32_t property_id, void* value, void* pspec), "pupp", object, property_id, value, pspec);
+WRAPPER(GObject, dispose, void, (void* object), "p", object);
+WRAPPER(GObject, finalize, void, (void* object), "p", object);
+WRAPPER(GObject, dispatch_properties_changed, void*, (size_t type, uint32_t n_pspecs, void* pspecs), "Lup", type, n_pspecs, pspecs);
+WRAPPER(GObject, notify, void*, (size_t type, void* pspecs), "Lp", type, pspecs);
+WRAPPER(GObject, constructed, void, (void* object), "p", object);
 
 #define SUPERGO() \
     GO(constructor, pFLup);                 \
@@ -163,7 +163,7 @@ static void wrapGObjectClass(my_GObjectClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGObjectClass(my_GObjectClass_t* class)
-{   
+{
     #define GO(A, W)   class->A = find_##A##_GObject (class->A)
     SUPERGO()
     #undef GO
@@ -179,14 +179,14 @@ static void bridgeGObjectClass(my_GObjectClass_t* class)
 
 // ----- GInitiallyUnownedClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GInitiallyUnowned, constructor, void*, (size_t type, uint32_t n_construct_properties, void* construct_properties), 3, type, n_construct_properties, construct_properties);
-WRAPPER(GInitiallyUnowned, set_property, void, (void* object, uint32_t property_id, void* value, void* pspec), 4, object, property_id, value, pspec);
-WRAPPER(GInitiallyUnowned, get_property, void, (void* object, uint32_t property_id, void* value, void* pspec), 4, object, property_id, value, pspec);
-WRAPPER(GInitiallyUnowned, dispose, void, (void* object), 1, object);
-WRAPPER(GInitiallyUnowned, finalize, void, (void* object), 1, object);
-WRAPPER(GInitiallyUnowned, dispatch_properties_changed, void*, (size_t type, uint32_t n_pspecs, void* pspecs), 3, type, n_pspecs, pspecs);
-WRAPPER(GInitiallyUnowned, notify, void*, (size_t type, void* pspecs), 2, type, pspecs);
-WRAPPER(GInitiallyUnowned, constructed, void, (void* object), 1, object);
+WRAPPER(GInitiallyUnowned, constructor, void*, (size_t type, uint32_t n_construct_properties, void* construct_properties), "Lup", type, n_construct_properties, construct_properties);
+WRAPPER(GInitiallyUnowned, set_property, void, (void* object, uint32_t property_id, void* value, void* pspec), "pupp", object, property_id, value, pspec);
+WRAPPER(GInitiallyUnowned, get_property, void, (void* object, uint32_t property_id, void* value, void* pspec), "pupp", object, property_id, value, pspec);
+WRAPPER(GInitiallyUnowned, dispose, void, (void* object), "p", object);
+WRAPPER(GInitiallyUnowned, finalize, void, (void* object), "p", object);
+WRAPPER(GInitiallyUnowned, dispatch_properties_changed, void*, (size_t type, uint32_t n_pspecs, void* pspecs), "Lup", type, n_pspecs, pspecs);
+WRAPPER(GInitiallyUnowned, notify, void*, (size_t type, void* pspecs), "Lp", type, pspecs);
+WRAPPER(GInitiallyUnowned, constructed, void, (void* object), "p", object);
 
 #define SUPERGO() \
     GO(constructor, pFLup);                 \
@@ -207,7 +207,7 @@ static void wrapGInitiallyUnownedClass(my_GInitiallyUnownedClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGInitiallyUnownedClass(my_GInitiallyUnownedClass_t* class)
-{   
+{
     #define GO(A, W)   class->A = find_##A##_GInitiallyUnowned (class->A)
     SUPERGO()
     #undef GO
@@ -223,7 +223,7 @@ static void bridgeGInitiallyUnownedClass(my_GInitiallyUnownedClass_t* class)
 
 // ----- GamesScoresImporterClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GamesScoresImporter, importOldScores, void, (void *self, void* context, void* new_scores_dir, void *error), 4, self, context, new_scores_dir, error);
+WRAPPER(GamesScoresImporter, importOldScores, void, (void *self, void* context, void* new_scores_dir, void *error), "pppp", self, context, new_scores_dir, error);
 
 #define SUPERGO() \
     GO(importOldScores, vFpppp);
@@ -256,21 +256,21 @@ static void bridgeGamesScoresImporterClass(my_GamesScoresImporterClass_t* class)
 
 // ----- GApplicationClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GApplication, startup, void, (void* application), 1, application);
-WRAPPER(GApplication, activate, void, (void* application), 1, application);
-WRAPPER(GApplication, open, void, (void* application, void* files, int n_files, void* hint), 4, application, files, n_files, hint);
-WRAPPER(GApplication, command_line, void, (void* application, void* command_line), 2, application, command_line);
-WRAPPER(GApplication, local_command_line, void, (void* application, void* arguments, void* exit_status), 3, application, arguments, exit_status);
-WRAPPER(GApplication, before_emit, void*, (void* application, void* platform_data), 2, application, platform_data);
-WRAPPER(GApplication, after_emit, void, (void* application, void* platform_data), 2, application, platform_data);
-WRAPPER(GApplication, add_platform_data, void, (void* application, void* builder), 2, application, builder);
-WRAPPER(GApplication, quit_mainloop, void, (void* application), 1, application);
-WRAPPER(GApplication, run_mainloop, void, (void* application), 1, application);
-WRAPPER(GApplication, shutdown, void, (void* application), 1, application);
-WRAPPER(GApplication, dbus_register, void, (void* application, void* connection, void* object_path, void* error), 4, application, connection, object_path, error);
-WRAPPER(GApplication, dbus_unregister, void, (void* application, void* connection, void* object_path), 3, application, connection, object_path);
-WRAPPER(GApplication, handle_local_options, void, (void* application, void* options), 2, application, options);
-WRAPPER(GApplication, name_lost, void, (void* application), 1, application);
+WRAPPER(GApplication, startup, void, (void* application), "p", application);
+WRAPPER(GApplication, activate, void, (void* application), "p", application);
+WRAPPER(GApplication, open, void, (void* application, void* files, int n_files, void* hint), "ppip", application, files, n_files, hint);
+WRAPPER(GApplication, command_line, void, (void* application, void* command_line), "pp", application, command_line);
+WRAPPER(GApplication, local_command_line, void, (void* application, void* arguments, void* exit_status), "ppp", application, arguments, exit_status);
+WRAPPER(GApplication, before_emit, void*, (void* application, void* platform_data), "pp", application, platform_data);
+WRAPPER(GApplication, after_emit, void, (void* application, void* platform_data), "pp", application, platform_data);
+WRAPPER(GApplication, add_platform_data, void, (void* application, void* builder), "pp", application, builder);
+WRAPPER(GApplication, quit_mainloop, void, (void* application), "p", application);
+WRAPPER(GApplication, run_mainloop, void, (void* application), "p", application);
+WRAPPER(GApplication, shutdown, void, (void* application), "p", application);
+WRAPPER(GApplication, dbus_register, void, (void* application, void* connection, void* object_path, void* error), "pppp", application, connection, object_path, error);
+WRAPPER(GApplication, dbus_unregister, void, (void* application, void* connection, void* object_path), "ppp", application, connection, object_path);
+WRAPPER(GApplication, handle_local_options, void, (void* application, void* options), "pp", application, options);
+WRAPPER(GApplication, name_lost, void, (void* application), "p", application);
 
 #define SUPERGO()                     \
     GO(startup, vFp);                 \
@@ -315,8 +315,8 @@ static void bridgeGApplicationClass(my_GApplicationClass_t* class)
 
 // ----- GtkApplicationClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkApplication, window_added, void, (void* application, void* window), 2, application, window);
-WRAPPER(GtkApplication, window_removed, void, (void* application, void* window), 2, application, window);
+WRAPPER(GtkApplication, window_added, void, (void* application, void* window), "pp", application, window);
+WRAPPER(GtkApplication, window_removed, void, (void* application, void* window), "pp", application, window);
 
 #define SUPERGO() \
     GO(window_added, pFpp);   \
@@ -350,9 +350,9 @@ static void bridgeGtkApplicationClass(my_GtkApplicationClass_t* class)
 
 // ----- GtkObjectClass ------
 // wrapper x64 -> natives of callbacks
-WRAPPER(GtkObject, set_arg, void, (void* object, void* arg, uint32_t arg_id), 3, object, arg, arg_id);
-WRAPPER(GtkObject, get_arg, void, (void* object, void* arg, uint32_t arg_id), 3, object, arg, arg_id);
-WRAPPER(GtkObject, destroy, void, (void* object), 1, object);
+WRAPPER(GtkObject, set_arg, void, (void* object, void* arg, uint32_t arg_id), "ppu", object, arg, arg_id);
+WRAPPER(GtkObject, get_arg, void, (void* object, void* arg, uint32_t arg_id), "ppu", object, arg, arg_id);
+WRAPPER(GtkObject, destroy, void, (void* object), "p", object);
 
 #define SUPERGO() \
     GO(set_arg, vFppu); \
@@ -368,7 +368,7 @@ static void wrapGtkObjectClass(my_GtkObjectClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkObjectClass(my_GtkObjectClass_t* class)
-{   
+{
     unwrapGObjectClass(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkObject (class->A)
     SUPERGO()
@@ -387,72 +387,72 @@ static void bridgeGtkObjectClass(my_GtkObjectClass_t* class)
 
 // ----- GtkWidget2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkWidget2, dispatch_child_properties_changed, void, (void* widget, uint32_t n_pspecs, void* pspecs), 3, widget, n_pspecs, pspecs);
-WRAPPER(GtkWidget2, show,              void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, show_all,          void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, hide,              void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, hide_all,          void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, map,               void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, unmap,             void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, realize,           void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, unrealize,         void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, size_request,      void, (void* widget, void* requisition), 2, widget, requisition);
-WRAPPER(GtkWidget2, size_allocate,     void, (void* widget, void* allocation), 2, widget, allocation);
-WRAPPER(GtkWidget2, state_changed,     void, (void* widget, int previous_state), 2, widget, previous_state);
-WRAPPER(GtkWidget2, parent_set,        void, (void* widget, void* previous_parent), 2, widget, previous_parent);
-WRAPPER(GtkWidget2, hierarchy_changed, void, (void* widget, void* previous_toplevel), 2, widget, previous_toplevel);
-WRAPPER(GtkWidget2, style_set,         void, (void* widget, void* previous_style), 2, widget, previous_style);
-WRAPPER(GtkWidget2, direction_changed, void, (void* widget, int previous_direction), 2, widget, previous_direction);
-WRAPPER(GtkWidget2, grab_notify,       void, (void* widget, int was_grabbed), 2, widget, was_grabbed);
-WRAPPER(GtkWidget2, child_notify,      void, (void* widget, void* pspec), 2, widget, pspec);
-WRAPPER(GtkWidget2, mnemonic_activate, int, (void* widget, int group_cycling), 2, widget, group_cycling);
-WRAPPER(GtkWidget2, grab_focus,        void, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, focus,             int, (void* widget, int direction), 2, widget, direction);
-WRAPPER(GtkWidget2, event,             int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, button_press_event,int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, button_release_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, scroll_event,      int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, motion_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, delete_event,       int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, destroy_event,      int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, expose_event,       int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, key_press_event,    int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, key_release_event,  int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, enter_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, leave_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, configure_event,    int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, focus_in_event,     int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, focus_out_event,    int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, map_event,          int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, unmap_event,        int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, property_notify_event,  int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, selection_clear_event,  int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, selection_request_event,int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, selection_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, proximity_in_event,  int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, proximity_out_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, visibility_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, client_event,        int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, no_expose_event,     int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, window_state_event,  int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2, selection_get,       void, (void* widget, void* selection_data, uint32_t info, uint32_t time_), 4, widget, selection_data, info, time_);
-WRAPPER(GtkWidget2, selection_received,  void, (void* widget, void* selection_data, uint32_t time_), 3, widget, selection_data, time_);
-WRAPPER(GtkWidget2, drag_begin,          void, (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget2, drag_end,            void, (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget2, drag_data_get,       void, (void* widget, void* context, void* selection_data, uint32_t info, uint32_t time_), 5, widget, context, selection_data, info, time_);
-WRAPPER(GtkWidget2, drag_data_delete,    void, (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget2, drag_leave,          void, (void* widget, void* context, uint32_t time_), 3, widget, context, time_);
-WRAPPER(GtkWidget2, drag_motion,         int, (void* widget, void* context, int32_t x, int32_t y, uint32_t time_), 5, widget, context, x, y, time_);
-WRAPPER(GtkWidget2, drag_drop,           int, (void* widget, void* context, int32_t x, int32_t y, uint32_t time_), 5, widget, context, x, y, time_);
-WRAPPER(GtkWidget2, drag_data_received,  void, (void* widget, void* context, int32_t x, int32_t y, void* selection_data, uint32_t info, uint32_t time_), 7, widget, context, x, y, selection_data, info, time_);
-WRAPPER(GtkWidget2,  popup_menu,         int  , (void* widget), 1, widget);
-WRAPPER(GtkWidget2,  show_help,          int  , (void* widget, int help_type), 2, widget, help_type);
-WRAPPER(GtkWidget2, get_accessible,      void*, (void* widget), 1, widget);
-WRAPPER(GtkWidget2, screen_changed,      void , (void* widget, void* previous_screen), 2, widget, previous_screen);
-WRAPPER(GtkWidget2, can_activate_accel,  int  , (void* widget, uint32_t signal_id), 2, widget, signal_id);
-WRAPPER(GtkWidget2, grab_broken_event,   int  , (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget2,  composited_changed, void , (void* widget), 1, widget);
-WRAPPER(GtkWidget2,  query_tooltip,      int  , (void* widget, int32_t x, int32_t y, int keyboard_tooltip, void* tooltip), 5, widget, x, y, keyboard_tooltip, tooltip);
+WRAPPER(GtkWidget2, dispatch_child_properties_changed, void, (void* widget, uint32_t n_pspecs, void* pspecs), "pup", widget, n_pspecs, pspecs);
+WRAPPER(GtkWidget2, show,              void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, show_all,          void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, hide,              void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, hide_all,          void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, map,               void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, unmap,             void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, realize,           void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, unrealize,         void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, size_request,      void, (void* widget, void* requisition), "pp", widget, requisition);
+WRAPPER(GtkWidget2, size_allocate,     void, (void* widget, void* allocation), "pp", widget, allocation);
+WRAPPER(GtkWidget2, state_changed,     void, (void* widget, int previous_state), "pi", widget, previous_state);
+WRAPPER(GtkWidget2, parent_set,        void, (void* widget, void* previous_parent), "pp", widget, previous_parent);
+WRAPPER(GtkWidget2, hierarchy_changed, void, (void* widget, void* previous_toplevel), "pp", widget, previous_toplevel);
+WRAPPER(GtkWidget2, style_set,         void, (void* widget, void* previous_style), "pp", widget, previous_style);
+WRAPPER(GtkWidget2, direction_changed, void, (void* widget, int previous_direction), "pi", widget, previous_direction);
+WRAPPER(GtkWidget2, grab_notify,       void, (void* widget, int was_grabbed), "pi", widget, was_grabbed);
+WRAPPER(GtkWidget2, child_notify,      void, (void* widget, void* pspec), "pp", widget, pspec);
+WRAPPER(GtkWidget2, mnemonic_activate, int, (void* widget, int group_cycling), "pi", widget, group_cycling);
+WRAPPER(GtkWidget2, grab_focus,        void, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, focus,             int, (void* widget, int direction), "pi", widget, direction);
+WRAPPER(GtkWidget2, event,             int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, button_press_event,int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, button_release_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, scroll_event,      int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, motion_notify_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, delete_event,       int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, destroy_event,      int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, expose_event,       int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, key_press_event,    int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, key_release_event,  int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, enter_notify_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, leave_notify_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, configure_event,    int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, focus_in_event,     int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, focus_out_event,    int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, map_event,          int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, unmap_event,        int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, property_notify_event,  int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, selection_clear_event,  int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, selection_request_event,int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, selection_notify_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, proximity_in_event,  int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, proximity_out_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2, visibility_notify_event, int, (void* widget, void* event), "p", widget, event);
+WRAPPER(GtkWidget2, client_event,        int, (void* widget, void* event), "p", widget, event);
+WRAPPER(GtkWidget2, no_expose_event,     int, (void* widget, void* event), "p", widget, event);
+WRAPPER(GtkWidget2, window_state_event,  int, (void* widget, void* event), "p", widget, event);
+WRAPPER(GtkWidget2, selection_get,       void, (void* widget, void* selection_data, uint32_t info, uint32_t time_), "ppuu", widget, selection_data, info, time_);
+WRAPPER(GtkWidget2, selection_received,  void, (void* widget, void* selection_data, uint32_t time_), "ppu", widget, selection_data, time_);
+WRAPPER(GtkWidget2, drag_begin,          void, (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget2, drag_end,            void, (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget2, drag_data_get,       void, (void* widget, void* context, void* selection_data, uint32_t info, uint32_t time_), "pppuu", widget, context, selection_data, info, time_);
+WRAPPER(GtkWidget2, drag_data_delete,    void, (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget2, drag_leave,          void, (void* widget, void* context, uint32_t time_), "ppu", widget, context, time_);
+WRAPPER(GtkWidget2, drag_motion,         int, (void* widget, void* context, int32_t x, int32_t y, uint32_t time_), "ppiiu", widget, context, x, y, time_);
+WRAPPER(GtkWidget2, drag_drop,           int, (void* widget, void* context, int32_t x, int32_t y, uint32_t time_), "ppiiu", widget, context, x, y, time_);
+WRAPPER(GtkWidget2, drag_data_received,  void, (void* widget, void* context, int32_t x, int32_t y, void* selection_data, uint32_t info, uint32_t time_), "ppiipuu", widget, context, x, y, selection_data, info, time_);
+WRAPPER(GtkWidget2,  popup_menu,         int  , (void* widget), "p", widget);
+WRAPPER(GtkWidget2,  show_help,          int  , (void* widget, int help_type), "pi", widget, help_type);
+WRAPPER(GtkWidget2, get_accessible,      void*, (void* widget), "p", widget);
+WRAPPER(GtkWidget2, screen_changed,      void , (void* widget, void* previous_screen), "pp", widget, previous_screen);
+WRAPPER(GtkWidget2, can_activate_accel,  int  , (void* widget, uint32_t signal_id), "pu", widget, signal_id);
+WRAPPER(GtkWidget2, grab_broken_event,   int  , (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget2,  composited_changed, void , (void* widget), "p", widget);
+WRAPPER(GtkWidget2,  query_tooltip,      int  , (void* widget, int32_t x, int32_t y, int keyboard_tooltip, void* tooltip), "piiip", widget, x, y, keyboard_tooltip, tooltip);
 
 #define SUPERGO() \
     GO(dispatch_child_properties_changed, vFpup);   \
@@ -532,7 +532,7 @@ static void wrapGtkWidget2Class(my_GtkWidget2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkWidget2Class(my_GtkWidget2Class_t* class)
-{   
+{
     unwrapGtkObjectClass(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkWidget2 (class->A)
     SUPERGO()
@@ -551,88 +551,88 @@ static void bridgeGtkWidget2Class(my_GtkWidget2Class_t* class)
 
 // ----- GtkWidget3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkWidget3, dispatch_child_properties_changed, void, (void* widget, uint32_t n_pspecs, void* pspecs), 3, widget, n_pspecs, pspecs);
-WRAPPER(GtkWidget3, destroy, void,              (void* widget), 1, widget);
-WRAPPER(GtkWidget3, show, void,                 (void* widget), 1, widget);
-WRAPPER(GtkWidget3, show_all, void,             (void* widget), 1, widget);
-WRAPPER(GtkWidget3, hide, void,                 (void* widget), 1, widget);
-WRAPPER(GtkWidget3, map, void,                  (void* widget), 1, widget);
-WRAPPER(GtkWidget3, unmap, void,                (void* widget), 1, widget);
-WRAPPER(GtkWidget3, realize, void,              (void* widget), 1, widget);
-WRAPPER(GtkWidget3, unrealize, void,            (void* widget), 1, widget);
-WRAPPER(GtkWidget3, size_allocate, void,        (void* widget, void* allocation), 2, widget, allocation);
-WRAPPER(GtkWidget3, state_changed, void,        (void* widget, int previous_state), 2, widget, previous_state);
-WRAPPER(GtkWidget3, state_flags_changed, void,  (void* widget, int previous_state_flags), 2, widget, previous_state_flags);
-WRAPPER(GtkWidget3, parent_set, void,           (void* widget, void* previous_parent), 2, widget, previous_parent);
-WRAPPER(GtkWidget3, hierarchy_changed, void,    (void* widget, void* previous_toplevel), 2, widget, previous_toplevel);
-WRAPPER(GtkWidget3, style_set, void,            (void* widget, void* previous_style), 2, widget, previous_style);
-WRAPPER(GtkWidget3, direction_changed, void,    (void* widget, int previous_direction), 2, widget, previous_direction);
-WRAPPER(GtkWidget3, grab_notify, void,          (void* widget, int was_grabbed), 2, widget, was_grabbed);
-WRAPPER(GtkWidget3, child_notify, void,         (void* widget, void* child_property), 2, widget, child_property);
-WRAPPER(GtkWidget3, draw, int,                  (void* widget, void* cr), 2, widget, cr);
-WRAPPER(GtkWidget3, get_request_mode, int,      (void* widget), 1, widget);
-WRAPPER(GtkWidget3, get_preferred_height, void, (void* widget, void* minimum_height, void* natural_height), 3, widget, minimum_height, natural_height);
-WRAPPER(GtkWidget3, get_preferred_width_for_height, void,  (void* widget, int height, void* minimum_width, void* natural_width), 4, widget, height, minimum_width, natural_width);
-WRAPPER(GtkWidget3, get_preferred_width, void,  (void* widget, void* minimum_width, void* natural_width), 3, widget, minimum_width, natural_width);
-WRAPPER(GtkWidget3, get_preferred_height_for_width, void,  (void* widget, int width, void* minimum_height, void* natural_height), 4, widget, width, minimum_height, natural_height);
-WRAPPER(GtkWidget3, mnemonic_activate, int,     (void* widget, int group_cycling), 2, widget, group_cycling);
-WRAPPER(GtkWidget3, grab_focus, void,           (void* widget), 1, widget);
-WRAPPER(GtkWidget3, focus, int,                 (void* widget, int direction), 2, widget, direction);
-WRAPPER(GtkWidget3, move_focus, void,           (void* widget, int direction), 2, widget, direction);
-WRAPPER(GtkWidget3, keynav_failed, int,         (void* widget, int direction), 2, widget, direction);
-WRAPPER(GtkWidget3, event, int,                 (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, button_press_event, int,    (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, button_release_event, int,  (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, scroll_event, int,          (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, motion_notify_event, int,   (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, delete_event, int,          (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, destroy_event, int,         (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, key_press_event, int,       (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, key_release_event, int,     (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, enter_notify_event, int,    (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, leave_notify_event, int,    (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, configure_event, int,       (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, focus_in_event, int,        (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, focus_out_event, int,       (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, map_event, int,             (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, unmap_event, int,           (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, property_notify_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, selection_clear_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, selection_request_event, int, (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, selection_notify_event, int,(void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, proximity_in_event, int,    (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, proximity_out_event, int,   (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, visibility_notify_event, int,   (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, window_state_event, int,    (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, damage_event, int,          (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, grab_broken_event, int,     (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, selection_get, void,        (void* widget, void* selection_data, uint32_t info, uint32_t time_), 4, widget, selection_data, info, time_);
-WRAPPER(GtkWidget3, selection_received, void,   (void* widget, void* selection_data, uint32_t time_), 3, widget, selection_data, time_);
-WRAPPER(GtkWidget3, drag_begin, void,           (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget3, drag_end, void,             (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget3, drag_data_get, void,        (void* widget, void* context, void* selection_data, uint32_t info, uint32_t time_), 5, widget, context, selection_data, info, time_);
-WRAPPER(GtkWidget3, drag_data_delete, void,     (void* widget, void* context), 2, widget, context);
-WRAPPER(GtkWidget3, drag_leave, void,           (void* widget, void* context, uint32_t time_), 3, widget, context, time_);
-WRAPPER(GtkWidget3, drag_motion, int,           (void* widget, void* context, int x, int y, uint32_t time_), 5, widget, context, x, y, time_);
-WRAPPER(GtkWidget3, drag_drop, int,             (void* widget, void* context, int x, int y, uint32_t time_), 5, widget, context, x, y, time_);
-WRAPPER(GtkWidget3, drag_data_received, void,   (void* widget, void* context, int x, int y, void* selection_data, uint32_t info, uint32_t time_), 7, widget, context, x, y, selection_data, info, time_);
-WRAPPER(GtkWidget3, drag_failed, int,           (void* widget, void* context, int result), 3, widget, context, result);
-WRAPPER(GtkWidget3, popup_menu, int,            (void* widget), 1, widget);
-WRAPPER(GtkWidget3, show_help, int,             (void* widget, int help_type), 2, widget, help_type);
-WRAPPER(GtkWidget3, get_accessible, void*,      (void *widget), 1, widget);
-WRAPPER(GtkWidget3, screen_changed, void,       (void* widget, void* previous_screen), 2, widget, previous_screen);
-WRAPPER(GtkWidget3, can_activate_accel, int,    (void* widget, uint32_t signal_id), 2, widget, signal_id);
-WRAPPER(GtkWidget3, composited_changed, void,   (void* widget), 1, widget);
-WRAPPER(GtkWidget3, query_tooltip, int,         (void* widget, int x, int y, int keyboard_tooltip, void* tooltip), 5, widget, x, y, keyboard_tooltip, tooltip);
-WRAPPER(GtkWidget3, compute_expand, void,       (void* widget, void* hexpand_p, void* vexpand_p), 3, widget, hexpand_p, vexpand_p);
-WRAPPER(GtkWidget3, adjust_size_request, void,  (void* widget, int orientation, void* minimum_size, void* natural_size), 4, widget, orientation, minimum_size, natural_size);
-WRAPPER(GtkWidget3, adjust_size_allocation, void, (void*widget, int orientation, void* minimum_size, void* natural_size, void* allocated_pos, void* allocated_size), 6, widget, orientation, minimum_size, natural_size, allocated_pos, allocated_size);
-WRAPPER(GtkWidget3, style_updated, void,        (void* widget), 1, widget);
-WRAPPER(GtkWidget3, touch_event, int,           (void* widget, void* event), 2, widget, event);
-WRAPPER(GtkWidget3, get_preferred_height_and_baseline_for_width, void, (void* widget, int width, void* minimum_height, void* natural_height, void* minimum_baseline, void* natural_baseline), 6, widget, width, minimum_height, natural_height, minimum_baseline, natural_baseline);
-WRAPPER(GtkWidget3, adjust_baseline_request, void,  (void* widget, void* minimum_baseline, void* natural_baseline), 3, widget, minimum_baseline, natural_baseline);
-WRAPPER(GtkWidget3, adjust_baseline_allocation, void,  (void* widget, void* baseline), 2, widget, baseline);
-WRAPPER(GtkWidget3, queue_draw_region, void,    (void* widget, void* region), 2, widget, region);
+WRAPPER(GtkWidget3, dispatch_child_properties_changed, void, (void* widget, uint32_t n_pspecs, void* pspecs), "pup", widget, n_pspecs, pspecs);
+WRAPPER(GtkWidget3, destroy, void,              (void* widget), "p", widget);
+WRAPPER(GtkWidget3, show, void,                 (void* widget), "p", widget);
+WRAPPER(GtkWidget3, show_all, void,             (void* widget), "p", widget);
+WRAPPER(GtkWidget3, hide, void,                 (void* widget), "p", widget);
+WRAPPER(GtkWidget3, map, void,                  (void* widget), "p", widget);
+WRAPPER(GtkWidget3, unmap, void,                (void* widget), "p", widget);
+WRAPPER(GtkWidget3, realize, void,              (void* widget), "p", widget);
+WRAPPER(GtkWidget3, unrealize, void,            (void* widget), "p", widget);
+WRAPPER(GtkWidget3, size_allocate, void,        (void* widget, void* allocation), "pp", widget, allocation);
+WRAPPER(GtkWidget3, state_changed, void,        (void* widget, int previous_state), "pi", widget, previous_state);
+WRAPPER(GtkWidget3, state_flags_changed, void,  (void* widget, int previous_state_flags), "pi", widget, previous_state_flags);
+WRAPPER(GtkWidget3, parent_set, void,           (void* widget, void* previous_parent), "pp", widget, previous_parent);
+WRAPPER(GtkWidget3, hierarchy_changed, void,    (void* widget, void* previous_toplevel), "pp", widget, previous_toplevel);
+WRAPPER(GtkWidget3, style_set, void,            (void* widget, void* previous_style), "pp", widget, previous_style);
+WRAPPER(GtkWidget3, direction_changed, void,    (void* widget, int previous_direction), "pi", widget, previous_direction);
+WRAPPER(GtkWidget3, grab_notify, void,          (void* widget, int was_grabbed), "pi", widget, was_grabbed);
+WRAPPER(GtkWidget3, child_notify, void,         (void* widget, void* child_property), "pp", widget, child_property);
+WRAPPER(GtkWidget3, draw, int,                  (void* widget, void* cr), "pp", widget, cr);
+WRAPPER(GtkWidget3, get_request_mode, int,      (void* widget), "p", widget);
+WRAPPER(GtkWidget3, get_preferred_height, void, (void* widget, void* minimum_height, void* natural_height), "ppp", widget, minimum_height, natural_height);
+WRAPPER(GtkWidget3, get_preferred_width_for_height, void,  (void* widget, int height, void* minimum_width, void* natural_width), "pipp", widget, height, minimum_width, natural_width);
+WRAPPER(GtkWidget3, get_preferred_width, void,  (void* widget, void* minimum_width, void* natural_width), "ppp", widget, minimum_width, natural_width);
+WRAPPER(GtkWidget3, get_preferred_height_for_width, void,  (void* widget, int width, void* minimum_height, void* natural_height), "pipp", widget, width, minimum_height, natural_height);
+WRAPPER(GtkWidget3, mnemonic_activate, int,     (void* widget, int group_cycling), "pi", widget, group_cycling);
+WRAPPER(GtkWidget3, grab_focus, void,           (void* widget), "p", widget);
+WRAPPER(GtkWidget3, focus, int,                 (void* widget, int direction), "pi", widget, direction);
+WRAPPER(GtkWidget3, move_focus, void,           (void* widget, int direction), "pi", widget, direction);
+WRAPPER(GtkWidget3, keynav_failed, int,         (void* widget, int direction), "pi", widget, direction);
+WRAPPER(GtkWidget3, event, int,                 (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, button_press_event, int,    (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, button_release_event, int,  (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, scroll_event, int,          (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, motion_notify_event, int,   (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, delete_event, int,          (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, destroy_event, int,         (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, key_press_event, int,       (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, key_release_event, int,     (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, enter_notify_event, int,    (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, leave_notify_event, int,    (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, configure_event, int,       (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, focus_in_event, int,        (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, focus_out_event, int,       (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, map_event, int,             (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, unmap_event, int,           (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, property_notify_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, selection_clear_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, selection_request_event, int, (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, selection_notify_event, int,(void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, proximity_in_event, int,    (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, proximity_out_event, int,   (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, visibility_notify_event, int,   (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, window_state_event, int,    (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, damage_event, int,          (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, grab_broken_event, int,     (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, selection_get, void,        (void* widget, void* selection_data, uint32_t info, uint32_t time_), "ppuu", widget, selection_data, info, time_);
+WRAPPER(GtkWidget3, selection_received, void,   (void* widget, void* selection_data, uint32_t time_), "ppu", widget, selection_data, time_);
+WRAPPER(GtkWidget3, drag_begin, void,           (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget3, drag_end, void,             (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget3, drag_data_get, void,        (void* widget, void* context, void* selection_data, uint32_t info, uint32_t time_), "pppuu", widget, context, selection_data, info, time_);
+WRAPPER(GtkWidget3, drag_data_delete, void,     (void* widget, void* context), "pp", widget, context);
+WRAPPER(GtkWidget3, drag_leave, void,           (void* widget, void* context, uint32_t time_), "ppu", widget, context, time_);
+WRAPPER(GtkWidget3, drag_motion, int,           (void* widget, void* context, int x, int y, uint32_t time_), "ppiiu", widget, context, x, y, time_);
+WRAPPER(GtkWidget3, drag_drop, int,             (void* widget, void* context, int x, int y, uint32_t time_), "ppiiu", widget, context, x, y, time_);
+WRAPPER(GtkWidget3, drag_data_received, void,   (void* widget, void* context, int x, int y, void* selection_data, uint32_t info, uint32_t time_), "ppiipuu", widget, context, x, y, selection_data, info, time_);
+WRAPPER(GtkWidget3, drag_failed, int,           (void* widget, void* context, int result), "ppi", widget, context, result);
+WRAPPER(GtkWidget3, popup_menu, int,            (void* widget), "p", widget);
+WRAPPER(GtkWidget3, show_help, int,             (void* widget, int help_type), "pi", widget, help_type);
+WRAPPER(GtkWidget3, get_accessible, void*,      (void *widget), "p", widget);
+WRAPPER(GtkWidget3, screen_changed, void,       (void* widget, void* previous_screen), "pp", widget, previous_screen);
+WRAPPER(GtkWidget3, can_activate_accel, int,    (void* widget, uint32_t signal_id), "pu", widget, signal_id);
+WRAPPER(GtkWidget3, composited_changed, void,   (void* widget), "p", widget);
+WRAPPER(GtkWidget3, query_tooltip, int,         (void* widget, int x, int y, int keyboard_tooltip, void* tooltip), "piiip", widget, x, y, keyboard_tooltip, tooltip);
+WRAPPER(GtkWidget3, compute_expand, void,       (void* widget, void* hexpand_p, void* vexpand_p), "ppp", widget, hexpand_p, vexpand_p);
+WRAPPER(GtkWidget3, adjust_size_request, void,  (void* widget, int orientation, void* minimum_size, void* natural_size), "pipp", widget, orientation, minimum_size, natural_size);
+WRAPPER(GtkWidget3, adjust_size_allocation, void, (void*widget, int orientation, void* minimum_size, void* natural_size, void* allocated_pos, void* allocated_size), "pipppp", widget, orientation, minimum_size, natural_size, allocated_pos, allocated_size);
+WRAPPER(GtkWidget3, style_updated, void,        (void* widget), "p", widget);
+WRAPPER(GtkWidget3, touch_event, int,           (void* widget, void* event), "pp", widget, event);
+WRAPPER(GtkWidget3, get_preferred_height_and_baseline_for_width, void, (void* widget, int width, void* minimum_height, void* natural_height, void* minimum_baseline, void* natural_baseline), "pipppp", widget, width, minimum_height, natural_height, minimum_baseline, natural_baseline);
+WRAPPER(GtkWidget3, adjust_baseline_request, void,  (void* widget, void* minimum_baseline, void* natural_baseline), "ppp", widget, minimum_baseline, natural_baseline);
+WRAPPER(GtkWidget3, adjust_baseline_allocation, void,  (void* widget, void* baseline), "pp", widget, baseline);
+WRAPPER(GtkWidget3, queue_draw_region, void,    (void* widget, void* region), "pp", widget, region);
 
 #define SUPERGO() \
     GO(dispatch_child_properties_changed, vFpup);   \
@@ -729,7 +729,7 @@ static void wrapGtkWidget3Class(my_GtkWidget3Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkWidget3Class(my_GtkWidget3Class_t* class)
-{   
+{
     unwrapGInitiallyUnownedClass(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkWidget3 (class->A)
     SUPERGO()
@@ -748,15 +748,15 @@ static void bridgeGtkWidget3Class(my_GtkWidget3Class_t* class)
 
 // ----- GtkContainer2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkContainer2, add, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer2, remove, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer2, check_resize, void, (void* container), 1, container);
-WRAPPER(GtkContainer2, forall, void, (void* container, int include_internals, void* callback, void* callback_data), 4, container, include_internals, AddCheckBridge(my_bridge, vFpp, callback, 0, NULL), callback_data);
-WRAPPER(GtkContainer2, set_focus_child, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer2, child_type, int, (void* container), 1, container);
-WRAPPER(GtkContainer2, composite_name, void*, (void* container, void* child), 2, container, child);
-WRAPPER(GtkContainer2, set_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), 5, container, child, property_id, value, pspec);
-WRAPPER(GtkContainer2, get_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), 5, container, child, property_id, value, pspec);
+WRAPPER(GtkContainer2, add, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer2, remove, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer2, check_resize, void, (void* container), "p", container);
+WRAPPER(GtkContainer2, forall, void, (void* container, int include_internals, void* callback, void* callback_data), "pipp", container, include_internals, AddCheckBridge(my_bridge, vFpp, callback, 0, NULL), callback_data);
+WRAPPER(GtkContainer2, set_focus_child, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer2, child_type, int, (void* container), "p", container);
+WRAPPER(GtkContainer2, composite_name, void*, (void* container, void* child), "pp", container, child);
+WRAPPER(GtkContainer2, set_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), "ppupp", container, child, property_id, value, pspec);
+WRAPPER(GtkContainer2, get_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), "ppupp", container, child, property_id, value, pspec);
 
 #define SUPERGO() \
     GO(add, vFpp);                  \
@@ -779,7 +779,7 @@ static void wrapGtkContainer2Class(my_GtkContainer2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkContainer2Class(my_GtkContainer2Class_t* class)
-{   
+{
     unwrapGtkWidget2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkContainer2 (class->A)
     SUPERGO()
@@ -798,16 +798,16 @@ static void bridgeGtkContainer2Class(my_GtkContainer2Class_t* class)
 
 // ----- GtkContainer3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkContainer3, add, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer3, remove, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer3, check_resize, void, (void* container), 1, container);
-WRAPPER(GtkContainer3, forall, void, (void* container, int include_internals, void* callback, void* callback_data), 4, container, include_internals, AddCheckBridge(my_bridge, vFpp, callback, 0, NULL), callback_data);
-WRAPPER(GtkContainer3, set_focus_child, void, (void* container, void* widget), 2, container, widget);
-WRAPPER(GtkContainer3, child_type, int, (void* container), 1, container);
-WRAPPER(GtkContainer3, composite_name, void*, (void* container, void* child), 2, container, child);
-WRAPPER(GtkContainer3, set_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), 5, container, child, property_id, value, pspec);
-WRAPPER(GtkContainer3, get_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), 5, container, child, property_id, value, pspec);
-WRAPPER(GtkContainer3, get_path_for_child, void*, (void* container, void* child), 2, container, child);
+WRAPPER(GtkContainer3, add, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer3, remove, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer3, check_resize, void, (void* container), "p", container);
+WRAPPER(GtkContainer3, forall, void, (void* container, int include_internals, void* callback, void* callback_data), "pipp", container, include_internals, AddCheckBridge(my_bridge, vFpp, callback, 0, NULL), callback_data);
+WRAPPER(GtkContainer3, set_focus_child, void, (void* container, void* widget), "pp", container, widget);
+WRAPPER(GtkContainer3, child_type, int, (void* container), "p", container);
+WRAPPER(GtkContainer3, composite_name, void*, (void* container, void* child), "pp", container, child);
+WRAPPER(GtkContainer3, set_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), "ppupp", container, child, property_id, value, pspec);
+WRAPPER(GtkContainer3, get_child_property, void, (void* container, void* child, uint32_t property_id, void* value, void* pspec), "ppupp", container, child, property_id, value, pspec);
+WRAPPER(GtkContainer3, get_path_for_child, void*, (void* container, void* child), "pp", container, child);
 
 #define SUPERGO() \
     GO(add, vFpp);                  \
@@ -831,7 +831,7 @@ static void wrapGtkContainer3Class(my_GtkContainer3Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkContainer3Class(my_GtkContainer3Class_t* class)
-{   
+{
     unwrapGtkWidget3Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkContainer3 (class->A)
     SUPERGO()
@@ -850,12 +850,12 @@ static void bridgeGtkContainer3Class(my_GtkContainer3Class_t* class)
 
 // ----- GtkActionClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkAction, activate, void, (void* action), 1, action);
-WRAPPER(GtkAction, create_menu_item, void*, (void* action), 1, action);
-WRAPPER(GtkAction, create_tool_item, void*, (void* action), 1, action);
-WRAPPER(GtkAction, connect_proxy, void , (void* action, void* proxy), 2, action, proxy);
-WRAPPER(GtkAction, disconnect_proxy, void , (void* action, void* proxy), 2, action, proxy);
-WRAPPER(GtkAction, create_menu, void*, (void* action), 1, action);
+WRAPPER(GtkAction, activate, void, (void* action), "p", action);
+WRAPPER(GtkAction, create_menu_item, void*, (void* action), "p", action);
+WRAPPER(GtkAction, create_tool_item, void*, (void* action), "p", action);
+WRAPPER(GtkAction, connect_proxy, void , (void* action, void* proxy), "pp", action, proxy);
+WRAPPER(GtkAction, disconnect_proxy, void , (void* action, void* proxy), "pp", action, proxy);
+WRAPPER(GtkAction, create_menu, void*, (void* action), "p", action);
 
 #define SUPERGO() \
     GO(activate, vFp);          \
@@ -875,7 +875,7 @@ static void wrapGtkActionClass(my_GtkActionClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkActionClass(my_GtkActionClass_t* class)
-{   
+{
     unwrapGObjectClass(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkAction (class->A)
     SUPERGO()
@@ -900,7 +900,7 @@ static void wrapGtkMisc2Class(my_GtkMisc2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkMisc2Class(my_GtkMisc2Class_t* class)
-{   
+{
     unwrapGtkWidget2Class(&class->parent_class);
 }
 // autobridge
@@ -943,7 +943,7 @@ static void bridgeGtkMisc3Class(my_GtkMisc3Class_t* class)
 
 // ----- GtkGtkMenuButtonClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkMenuButton, activate, void, (void* self), 1, self);
+WRAPPER(GtkMenuButton, activate, void, (void* self), "p", self);
 
 #define SUPERGO() \
     GO(activate, vFp);
@@ -976,10 +976,10 @@ static void bridgeGtkMenuButtonClass(my_GtkMenuButtonClass_t* class)
 
 // ----- GtkLabel2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkLabel2, move_cursor, void, (void* label, int step, int count, int extend_selection), 4, label, step, count, extend_selection);
-WRAPPER(GtkLabel2, copy_clipboard, void, (void* label), 1, label);
-WRAPPER(GtkLabel2, populate_popup, void, (void* label, void* menu), 2, label, menu);
-WRAPPER(GtkLabel2, activate_link, int, (void* label, void* uri), 2, label, uri);
+WRAPPER(GtkLabel2, move_cursor, void, (void* label, int step, int count, int extend_selection), "piii", label, step, count, extend_selection);
+WRAPPER(GtkLabel2, copy_clipboard, void, (void* label), "p", label);
+WRAPPER(GtkLabel2, populate_popup, void, (void* label, void* menu), "pp", label, menu);
+WRAPPER(GtkLabel2, activate_link, int, (void* label, void* uri), "pp", label, uri);
 
 #define SUPERGO() \
     GO(move_cursor, vFpiii);    \
@@ -997,7 +997,7 @@ static void wrapGtkLabel2Class(my_GtkLabel2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkLabel2Class(my_GtkLabel2Class_t* class)
-{   
+{
     unwrapGtkMisc2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkLabel2 (class->A)
     SUPERGO()
@@ -1015,10 +1015,10 @@ static void bridgeGtkLabel2Class(my_GtkLabel2Class_t* class)
 
 // ----- GtkLabel3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkLabel3, move_cursor, void, (void* label, int step, int count, int extend_selection), 4, label, step, count, extend_selection);
-WRAPPER(GtkLabel3, copy_clipboard, void, (void* label), 1, label);
-WRAPPER(GtkLabel3, populate_popup, void, (void* label, void* menu), 2, label, menu);
-WRAPPER(GtkLabel3, activate_link, int, (void* label, void* uri), 2, label, uri);
+WRAPPER(GtkLabel3, move_cursor, void, (void* label, int step, int count, int extend_selection), "piii", label, step, count, extend_selection);
+WRAPPER(GtkLabel3, copy_clipboard, void, (void* label), "p", label);
+WRAPPER(GtkLabel3, populate_popup, void, (void* label, void* menu), "pp", label, menu);
+WRAPPER(GtkLabel3, activate_link, int, (void* label, void* uri), "pp", label, uri);
 
 #define SUPERGO() \
     GO(move_cursor, vFpiii);    \
@@ -1055,22 +1055,22 @@ static void bridgeGtkLabel3Class(my_GtkLabel3Class_t* class)
 
 // ----- GtkTreeView2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkTreeView2, set_scroll_adjustments, void, (void* tree_view, void* hadjustment, void* vadjustment), 3, tree_view, hadjustment, vadjustment);
-WRAPPER(GtkTreeView2, row_activated, void, (void* tree_view, void* path, void* column), 3, tree_view, path, column);
-WRAPPER(GtkTreeView2, test_expand_row, int, (void* tree_view, void* iter, void* path), 3, tree_view, iter, path);
-WRAPPER(GtkTreeView2, test_collapse_row, int, (void* tree_view, void* iter, void* path), 3, tree_view, iter, path);
-WRAPPER(GtkTreeView2, row_expanded, void, (void* tree_view, void* iter, void* path), 3, tree_view, iter, path);
-WRAPPER(GtkTreeView2, row_collapsed, void, (void* tree_view, void* iter, void* path), 3, tree_view, iter, path);
-WRAPPER(GtkTreeView2, columns_changed, void, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, cursor_changed, void, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, move_cursor, int, (void* tree_view, int step, int count), 3, tree_view, step, count);
-WRAPPER(GtkTreeView2, select_all, int, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, unselect_all, int, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, select_cursor_row, int, (void* tree_view, int start_editing), 2, tree_view, start_editing);
-WRAPPER(GtkTreeView2, toggle_cursor_row, int, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, expand_collapse_cursor_row, int, (void* tree_view, int logical, int expand, int open_all), 4, tree_view, logical, expand, open_all);
-WRAPPER(GtkTreeView2, select_cursor_parent, int, (void* tree_view), 1, tree_view);
-WRAPPER(GtkTreeView2, start_interactive_search, int, (void* tree_view), 1, tree_view);
+WRAPPER(GtkTreeView2, set_scroll_adjustments, void, (void* tree_view, void* hadjustment, void* vadjustment), "ppp", tree_view, hadjustment, vadjustment);
+WRAPPER(GtkTreeView2, row_activated, void, (void* tree_view, void* path, void* column), "ppp", tree_view, path, column);
+WRAPPER(GtkTreeView2, test_expand_row, int, (void* tree_view, void* iter, void* path), "ppp", tree_view, iter, path);
+WRAPPER(GtkTreeView2, test_collapse_row, int, (void* tree_view, void* iter, void* path), "ppp", tree_view, iter, path);
+WRAPPER(GtkTreeView2, row_expanded, void, (void* tree_view, void* iter, void* path), "ppp", tree_view, iter, path);
+WRAPPER(GtkTreeView2, row_collapsed, void, (void* tree_view, void* iter, void* path), "ppp", tree_view, iter, path);
+WRAPPER(GtkTreeView2, columns_changed, void, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, cursor_changed, void, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, move_cursor, int, (void* tree_view, int step, int count), "pii", tree_view, step, count);
+WRAPPER(GtkTreeView2, select_all, int, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, unselect_all, int, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, select_cursor_row, int, (void* tree_view, int start_editing), "pi", tree_view, start_editing);
+WRAPPER(GtkTreeView2, toggle_cursor_row, int, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, expand_collapse_cursor_row, int, (void* tree_view, int logical, int expand, int open_all), "piii", tree_view, logical, expand, open_all);
+WRAPPER(GtkTreeView2, select_cursor_parent, int, (void* tree_view), "p", tree_view);
+WRAPPER(GtkTreeView2, start_interactive_search, int, (void* tree_view), "p", tree_view);
 
 #define SUPERGO() \
     GO(set_scroll_adjustments, vFppp);      \
@@ -1100,7 +1100,7 @@ static void wrapGtkTreeView2Class(my_GtkTreeView2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkTreeView2Class(my_GtkTreeView2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkTreeView2 (class->A)
     SUPERGO()
@@ -1126,7 +1126,7 @@ static void wrapGtkBin2Class(my_GtkBin2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkBin2Class(my_GtkBin2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
 }
 // autobridge
@@ -1153,12 +1153,12 @@ static void bridgeGtkBin3Class(my_GtkBin3Class_t* class)
 
 // ----- GtkWindow2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkWindow2, set_focus, void, (void* window, void* focus), 2, window, focus);
-WRAPPER(GtkWindow2, frame_event, int, (void* window, void* event), 2, window, event);
-WRAPPER(GtkWindow2, activate_focus, void, (void* window), 1, window);
-WRAPPER(GtkWindow2, activate_default, void, (void* window), 1, window);
-WRAPPER(GtkWindow2, move_focus, void, (void* window, int direction), 2, window, direction);
-WRAPPER(GtkWindow2, keys_changed, void, (void* window), 1, window);
+WRAPPER(GtkWindow2, set_focus, void, (void* window, void* focus), "pp", window, focus);
+WRAPPER(GtkWindow2, frame_event, int, (void* window, void* event), "pp", window, event);
+WRAPPER(GtkWindow2, activate_focus, void, (void* window), "p", window);
+WRAPPER(GtkWindow2, activate_default, void, (void* window), "p", window);
+WRAPPER(GtkWindow2, move_focus, void, (void* window, int direction), "pi", window, direction);
+WRAPPER(GtkWindow2, keys_changed, void, (void* window), "p", window);
 
 #define SUPERGO()               \
     GO(set_focus, vFpp);        \
@@ -1179,7 +1179,7 @@ static void wrapGtkWindow2Class(my_GtkWindow2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkWindow2Class(my_GtkWindow2Class_t* class)
-{   
+{
     unwrapGtkBin2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkWindow2 (class->A)
     SUPERGO()
@@ -1198,11 +1198,11 @@ static void bridgeGtkWindow2Class(my_GtkWindow2Class_t* class)
 
 // ----- GtkWindow3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkWindow3, set_focus, void, (void* window, void* focus), 2, window, focus);
-WRAPPER(GtkWindow3, activate_focus, void, (void* window), 1, window);
-WRAPPER(GtkWindow3, activate_default, void, (void* window), 1, window);
-WRAPPER(GtkWindow3, keys_changed, void, (void* window), 1, window);
-WRAPPER(GtkWindow3, enable_debugging, int, (void* window, int toggle), 2, window, toggle);
+WRAPPER(GtkWindow3, set_focus, void, (void* window, void* focus), "pp", window, focus);
+WRAPPER(GtkWindow3, activate_focus, void, (void* window), "p", window);
+WRAPPER(GtkWindow3, activate_default, void, (void* window), "p", window);
+WRAPPER(GtkWindow3, keys_changed, void, (void* window), "p", window);
+WRAPPER(GtkWindow3, enable_debugging, int, (void* window, int toggle), "pi", window, toggle);
 
 #define SUPERGO()               \
     GO(set_focus, vFpp);        \
@@ -1258,14 +1258,14 @@ static void bridgeGtkApplicationWindowClass(my_GtkApplicationWindowClass_t* clas
 
 // ----- GtkListBoxClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkListBoxClass,row_selected, void, (void *box, void *row), 2, box, row);
-WRAPPER(GtkListBoxClass,row_activated, void, (void *box, void *row), 2, box, row);
-WRAPPER(GtkListBoxClass,activate_cursor_row, void, (void *box), 1, box);
-WRAPPER(GtkListBoxClass,toggle_cursor_row, void, (void *box), 1, box);
-WRAPPER(GtkListBoxClass,move_cursor, void, (void *box, int step, int count), 3, box, step, count);
-WRAPPER(GtkListBoxClass,selected_rows_changed, void, (void *box), 1, box);
-WRAPPER(GtkListBoxClass,select_all, void, (void *box), 1, box);
-WRAPPER(GtkListBoxClass,unselect_all, void, (void *box), 1, box);
+WRAPPER(GtkListBoxClass,row_selected, void, (void *box, void *row), "pp", box, row);
+WRAPPER(GtkListBoxClass,row_activated, void, (void *box, void *row), "pp", box, row);
+WRAPPER(GtkListBoxClass,activate_cursor_row, void, (void *box), "p", box);
+WRAPPER(GtkListBoxClass,toggle_cursor_row, void, (void *box), "p", box);
+WRAPPER(GtkListBoxClass,move_cursor, void, (void *box, int step, int count), "pii", box, step, count);
+WRAPPER(GtkListBoxClass,selected_rows_changed, void, (void *box), "p", box);
+WRAPPER(GtkListBoxClass,select_all, void, (void *box), "p", box);
+WRAPPER(GtkListBoxClass,unselect_all, void, (void *box), "p", box);
 
 #define SUPERGO()                  \
     GO(row_selected, vFpp);        \
@@ -1306,7 +1306,7 @@ static void bridgeGtkListBoxClass(my_GtkListBoxClass_t* class)
 
 // ----- GtkListBoxRowClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkListBoxRowClass, activate, void, (void *row), 1, row);
+WRAPPER(GtkListBoxRowClass, activate, void, (void *row), "p", row);
 
 #define SUPERGO()       \
     GO(activate, vFpp);
@@ -1346,7 +1346,7 @@ static void wrapGtkTable2Class(my_GtkTable2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkTable2Class(my_GtkTable2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
 }
 // autobridge
@@ -1364,7 +1364,7 @@ static void wrapGtkFixed2Class(my_GtkFixed2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkFixed2Class(my_GtkFixed2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
 }
 // autobridge
@@ -1382,7 +1382,7 @@ static void wrapMetaFrames2Class(my_MetaFrames2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapMetaFrames2Class(my_MetaFrames2Class_t* class)
-{   
+{
     unwrapGtkWindow2Class(&class->parent_class);
 }
 // autobridge
@@ -1393,8 +1393,8 @@ static void bridgeMetaFrames2Class(my_MetaFrames2Class_t* class)
 
 // ----- GDBusObjectManagerClientClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GDBusObjectManagerClient,interface_proxy_signal, void, (void* manager, void* object_proxy, void* interface_proxy, void* sender_name, void* signal_name, void* parameters), 6, manager, object_proxy, interface_proxy, sender_name, signal_name, parameters);
-WRAPPER(GDBusObjectManagerClient,interface_proxy_properties_changed, void, (void* manager, void* object_proxy, void* interface_proxy, void* changed_properties, void* invalidated_properties), 5, manager, object_proxy, interface_proxy, changed_properties, invalidated_properties);
+WRAPPER(GDBusObjectManagerClient,interface_proxy_signal, void, (void* manager, void* object_proxy, void* interface_proxy, void* sender_name, void* signal_name, void* parameters), "pppppp", manager, object_proxy, interface_proxy, sender_name, signal_name, parameters);
+WRAPPER(GDBusObjectManagerClient,interface_proxy_properties_changed, void, (void* manager, void* object_proxy, void* interface_proxy, void* changed_properties, void* invalidated_properties), "ppppp", manager, object_proxy, interface_proxy, changed_properties, invalidated_properties);
 
 #define SUPERGO()                                       \
     GO(interface_proxy_signal, vFpppppp);               \
@@ -1411,7 +1411,7 @@ static void wrapGDBusObjectManagerClientClass(my_GDBusObjectManagerClientClass_t
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGDBusObjectManagerClientClass(my_GDBusObjectManagerClientClass_t* class)
-{   
+{
     unwrapGObjectClass(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GDBusObjectManagerClient (class->A)
     SUPERGO()
@@ -1430,12 +1430,12 @@ static void bridgeGDBusObjectManagerClientClass(my_GDBusObjectManagerClientClass
 
 // ----- GtkButton2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkButton2, pressed, void,  (void* button), 1, button);
-WRAPPER(GtkButton2, released, void, (void* button), 1, button);
-WRAPPER(GtkButton2, clicked, void,  (void* button), 1, button);
-WRAPPER(GtkButton2, enter, void,    (void* button), 1, button);
-WRAPPER(GtkButton2, leave, void,    (void* button), 1, button);
-WRAPPER(GtkButton2, activate, void, (void* button), 1, button);
+WRAPPER(GtkButton2, pressed, void,  (void* button), "p", button);
+WRAPPER(GtkButton2, released, void, (void* button), "p", button);
+WRAPPER(GtkButton2, clicked, void,  (void* button), "p", button);
+WRAPPER(GtkButton2, enter, void,    (void* button), "p", button);
+WRAPPER(GtkButton2, leave, void,    (void* button), "p", button);
+WRAPPER(GtkButton2, activate, void, (void* button), "p", button);
 
 #define SUPERGO()               \
     GO(pressed, vFp);           \
@@ -1456,7 +1456,7 @@ static void wrapGtkButton2Class(my_GtkButton2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkButton2Class(my_GtkButton2Class_t* class)
-{   
+{
     unwrapGtkBin2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkButton2 (class->A)
     SUPERGO()
@@ -1475,12 +1475,12 @@ static void bridgeGtkButton2Class(my_GtkButton2Class_t* class)
 
 // ----- GtkButton3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkButton3, pressed, void,  (void* button), 1, button);
-WRAPPER(GtkButton3, released, void, (void* button), 1, button);
-WRAPPER(GtkButton3, clicked, void,  (void* button), 1, button);
-WRAPPER(GtkButton3, enter, void,    (void* button), 1, button);
-WRAPPER(GtkButton3, leave, void,    (void* button), 1, button);
-WRAPPER(GtkButton3, activate, void, (void* button), 1, button);
+WRAPPER(GtkButton3, pressed, void,  (void* button), "p", button);
+WRAPPER(GtkButton3, released, void, (void* button), "p", button);
+WRAPPER(GtkButton3, clicked, void,  (void* button), "p", button);
+WRAPPER(GtkButton3, enter, void,    (void* button), "p", button);
+WRAPPER(GtkButton3, leave, void,    (void* button), "p", button);
+WRAPPER(GtkButton3, activate, void, (void* button), "p", button);
 
 #define SUPERGO()               \
     GO(pressed, vFp);           \
@@ -1520,8 +1520,8 @@ static void bridgeGtkButton3Class(my_GtkButton3Class_t* class)
 
 // ----- GtkComboBox2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkComboBox2, changed, void, (void* combo_box), 1, combo_box);
-WRAPPER(GtkComboBox2, get_active_text, void*, (void* combo_box), 1, combo_box);
+WRAPPER(GtkComboBox2, changed, void, (void* combo_box), "p", combo_box);
+WRAPPER(GtkComboBox2, get_active_text, void*, (void* combo_box), "p", combo_box);
 
 #define SUPERGO()               \
     GO(changed, vFp);           \
@@ -1538,7 +1538,7 @@ static void wrapGtkComboBox2Class(my_GtkComboBox2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkComboBox2Class(my_GtkComboBox2Class_t* class)
-{   
+{
     unwrapGtkBin2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkComboBox2 (class->A)
     SUPERGO()
@@ -1557,7 +1557,7 @@ static void bridgeGtkComboBox2Class(my_GtkComboBox2Class_t* class)
 
 // ----- GtkToggleButton2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkToggleButton2, toggled, void, (void* toggle_button), 1, toggle_button);
+WRAPPER(GtkToggleButton2, toggled, void, (void* toggle_button), "p", toggle_button);
 
 #define SUPERGO()               \
     GO(toggled, vFp);           \
@@ -1573,7 +1573,7 @@ static void wrapGtkToggleButton2Class(my_GtkToggleButton2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkToggleButton2Class(my_GtkToggleButton2Class_t* class)
-{   
+{
     unwrapGtkButton2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkToggleButton2 (class->A)
     SUPERGO()
@@ -1592,7 +1592,7 @@ static void bridgeGtkToggleButton2Class(my_GtkToggleButton2Class_t* class)
 
 // ----- GtkCheckButton2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkCheckButton2, draw_indicator, void, (void* check_button, void* area), 2, check_button, area);
+WRAPPER(GtkCheckButton2, draw_indicator, void, (void* check_button, void* area), "pp", check_button, area);
 
 #define SUPERGO()               \
     GO(draw_indicator, vFpp);   \
@@ -1608,7 +1608,7 @@ static void wrapGtkCheckButton2Class(my_GtkCheckButton2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkCheckButton2Class(my_GtkCheckButton2Class_t* class)
-{   
+{
     unwrapGtkToggleButton2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkCheckButton2 (class->A)
     SUPERGO()
@@ -1627,17 +1627,17 @@ static void bridgeGtkCheckButton2Class(my_GtkCheckButton2Class_t* class)
 
 // ----- GtkEntry2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkEntry2, populate_popup, void,     (void* entry, void* menu), 2, entry, menu);
-WRAPPER(GtkEntry2, activate, void,           (void* entry), 1, entry);
-WRAPPER(GtkEntry2, move_cursor, void,        (void* entry, int step, int count, int extend_selection), 4, entry, step, count, extend_selection);
-WRAPPER(GtkEntry2, insert_at_cursor, void,   (void* entry, void* str), 2, entry, str);
-WRAPPER(GtkEntry2, delete_from_cursor, void, (void* entry, size_t type, int count), 3, entry, type, count);
-WRAPPER(GtkEntry2, backspace, void,          (void* entry), 1, entry);
-WRAPPER(GtkEntry2, cut_clipboard, void,      (void* entry), 1, entry);
-WRAPPER(GtkEntry2, copy_clipboard, void,     (void* entry), 1, entry);
-WRAPPER(GtkEntry2, paste_clipboard, void,    (void* entry), 1, entry);
-WRAPPER(GtkEntry2, toggle_overwrite, void,   (void* entry), 1, entry);
-WRAPPER(GtkEntry2, get_text_area_size, void, (void* entry, void* x, void* y, void* width, void* height), 5, entry, x, y, width, height);
+WRAPPER(GtkEntry2, populate_popup, void,     (void* entry, void* menu), "pp", entry, menu);
+WRAPPER(GtkEntry2, activate, void,           (void* entry), "p", entry);
+WRAPPER(GtkEntry2, move_cursor, void,        (void* entry, int step, int count, int extend_selection), "piii", entry, step, count, extend_selection);
+WRAPPER(GtkEntry2, insert_at_cursor, void,   (void* entry, void* str), "pp", entry, str);
+WRAPPER(GtkEntry2, delete_from_cursor, void, (void* entry, size_t type, int count), "pLi", entry, type, count);
+WRAPPER(GtkEntry2, backspace, void,          (void* entry), "p", entry);
+WRAPPER(GtkEntry2, cut_clipboard, void,      (void* entry), "p", entry);
+WRAPPER(GtkEntry2, copy_clipboard, void,     (void* entry), "p", entry);
+WRAPPER(GtkEntry2, paste_clipboard, void,    (void* entry), "p", entry);
+WRAPPER(GtkEntry2, toggle_overwrite, void,   (void* entry), "p", entry);
+WRAPPER(GtkEntry2, get_text_area_size, void, (void* entry, void* x, void* y, void* width, void* height), "ppppp", entry, x, y, width, height);
 
 #define SUPERGO()                   \
     GO(populate_popup, vFpp);       \
@@ -1662,7 +1662,7 @@ static void wrapGtkEntry2Class(my_GtkEntry2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkEntry2Class(my_GtkEntry2Class_t* class)
-{   
+{
     unwrapGtkWidget2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkEntry2 (class->A)
     SUPERGO()
@@ -1681,11 +1681,11 @@ static void bridgeGtkEntry2Class(my_GtkEntry2Class_t* class)
 
 // ----- GtkSpinButton2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkSpinButton2, input, int,  (void* spin_button, void* new_value), 2, spin_button, new_value);
-WRAPPER(GtkSpinButton2, output, int, (void* spin_button), 1, spin_button);
-WRAPPER(GtkSpinButton2, value_changed, void, (void* spin_button), 1, spin_button);
-WRAPPER(GtkSpinButton2, change_value, void, (void* spin_button, int scroll), 2, spin_button, scroll);
-WRAPPER(GtkSpinButton2, wrapped, void, (void* spin_button), 1, spin_button);
+WRAPPER(GtkSpinButton2, input, int,  (void* spin_button, void* new_value), "pp", spin_button, new_value);
+WRAPPER(GtkSpinButton2, output, int, (void* spin_button), "p", spin_button);
+WRAPPER(GtkSpinButton2, value_changed, void, (void* spin_button), "p", spin_button);
+WRAPPER(GtkSpinButton2, change_value, void, (void* spin_button, int scroll), "pi", spin_button, scroll);
+WRAPPER(GtkSpinButton2, wrapped, void, (void* spin_button), "p", spin_button);
 
 #define SUPERGO()           \
     GO(input, iFpp);        \
@@ -1704,7 +1704,7 @@ static void wrapGtkSpinButton2Class(my_GtkSpinButton2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkSpinButton2Class(my_GtkSpinButton2Class_t* class)
-{   
+{
     unwrapGtkEntry2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkSpinButton2 (class->A)
     SUPERGO()
@@ -1723,9 +1723,9 @@ static void bridgeGtkSpinButton2Class(my_GtkSpinButton2Class_t* class)
 
 // ----- GtkProgress2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkProgress2, paint, void,          (void* progress), 1, progress);
-WRAPPER(GtkProgress2, update, void,         (void* progress), 1, progress);
-WRAPPER(GtkProgress2, act_mode_enter, void, (void* progress), 1, progress);
+WRAPPER(GtkProgress2, paint, void,          (void* progress), "p", progress);
+WRAPPER(GtkProgress2, update, void,         (void* progress), "p", progress);
+WRAPPER(GtkProgress2, act_mode_enter, void, (void* progress), "p", progress);
 
 #define SUPERGO()           \
     GO(paint, vFp);         \
@@ -1742,7 +1742,7 @@ static void wrapGtkProgress2Class(my_GtkProgress2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkProgress2Class(my_GtkProgress2Class_t* class)
-{   
+{
     unwrapGtkWidget2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkProgress2 (class->A)
     SUPERGO()
@@ -1774,7 +1774,7 @@ static void wrapGtkProgressBar2Class(my_GtkProgressBar2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkProgressBar2Class(my_GtkProgressBar2Class_t* class)
-{   
+{
     unwrapGtkProgress2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkProgressBar2 (class->A)
     SUPERGO()
@@ -1793,7 +1793,7 @@ static void bridgeGtkProgressBar2Class(my_GtkProgressBar2Class_t* class)
 
 // ----- GtkFrame2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkFrame2, compute_child_allocation, void, (void* frame, void* allocation), 2, frame, allocation);
+WRAPPER(GtkFrame2, compute_child_allocation, void, (void* frame, void* allocation), "pp", frame, allocation);
 
 #define SUPERGO()                       \
     GO(compute_child_allocation, vFpp); \
@@ -1808,7 +1808,7 @@ static void wrapGtkFrame2Class(my_GtkFrame2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkFrame2Class(my_GtkFrame2Class_t* class)
-{   
+{
     unwrapGtkBin2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkFrame2 (class->A)
     SUPERGO()
@@ -1827,15 +1827,15 @@ static void bridgeGtkFrame2Class(my_GtkFrame2Class_t* class)
 
 // ----- GtkMenuShell2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkMenuShell2,deactivate, void,      (void* menu_shell), 1, menu_shell);
-WRAPPER(GtkMenuShell2,selection_done, void,  (void* menu_shell), 1, menu_shell);
-WRAPPER(GtkMenuShell2,move_current, void,    (void* menu_shell, int direction), 2, menu_shell, direction);
-WRAPPER(GtkMenuShell2,activate_current, void,(void* menu_shell, int force_hide), 2, menu_shell, force_hide);
-WRAPPER(GtkMenuShell2,cancel, void,          (void* menu_shell), 1, menu_shell);
-WRAPPER(GtkMenuShell2,select_item, void,     (void* menu_shell, void* menu_item), 2, menu_shell, menu_item);
-WRAPPER(GtkMenuShell2,insert, void,          (void* menu_shell, void* child, int position), 3, menu_shell, child, position);
-WRAPPER(GtkMenuShell2,get_popup_delay, int,  (void* menu_shell), 1, menu_shell);
-WRAPPER(GtkMenuShell2,move_selected, int,    (void* menu_shell, int distance), 2, menu_shell, distance);
+WRAPPER(GtkMenuShell2,deactivate, void,      (void* menu_shell), "p", menu_shell);
+WRAPPER(GtkMenuShell2,selection_done, void,  (void* menu_shell), "p", menu_shell);
+WRAPPER(GtkMenuShell2,move_current, void,    (void* menu_shell, int direction),  "pi", menu_shell, direction);
+WRAPPER(GtkMenuShell2,activate_current, void,(void* menu_shell, int force_hide), "pi", menu_shell, force_hide);
+WRAPPER(GtkMenuShell2,cancel, void,          (void* menu_shell), "p", menu_shell);
+WRAPPER(GtkMenuShell2,select_item, void,     (void* menu_shell, void* menu_item), "pp", menu_shell, menu_item);
+WRAPPER(GtkMenuShell2,insert, void,          (void* menu_shell, void* child, int position), "ppi", menu_shell, child, position);
+WRAPPER(GtkMenuShell2,get_popup_delay, int,  (void* menu_shell), "p", menu_shell);
+WRAPPER(GtkMenuShell2,move_selected, int,    (void* menu_shell, int distance), "pi", menu_shell, distance);
 
 #define SUPERGO()               \
     GO(deactivate, vFp);        \
@@ -1858,7 +1858,7 @@ static void wrapGtkMenuShell2Class(my_GtkMenuShell2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkMenuShell2Class(my_GtkMenuShell2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkMenuShell2 (class->A)
     SUPERGO()
@@ -1890,7 +1890,7 @@ static void wrapGtkMenuBar2Class(my_GtkMenuBar2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkMenuBar2Class(my_GtkMenuBar2Class_t* class)
-{   
+{
     unwrapGtkMenuShell2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkMenuBar2 (class->A)
     SUPERGO()
@@ -1909,19 +1909,19 @@ static void bridgeGtkMenuBar2Class(my_GtkMenuBar2Class_t* class)
 
 // ----- GtkTextView2Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkTextView2, set_scroll_adjustments, void,   (void* text_view, void* hadjustment, void* vadjustment), 3, text_view, hadjustment, vadjustment);
-WRAPPER(GtkTextView2, populate_popup, void,           (void* text_view, void* menu), 2, text_view, menu);
-WRAPPER(GtkTextView2, move_cursor, void,              (void* text_view, int step, int count, int extend_selection), 4, text_view, step, count, extend_selection);
-WRAPPER(GtkTextView2, page_horizontally, void,        (void* text_view, int count, int extend_selection), 3, text_view, count, extend_selection);
-WRAPPER(GtkTextView2, set_anchor, void,               (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, insert_at_cursor, void,         (void* text_view, void* str), 2, text_view, str);
-WRAPPER(GtkTextView2, delete_from_cursor, void,       (void* text_view, int type, int count), 3, text_view, type, count);
-WRAPPER(GtkTextView2, backspace, void,                (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, cut_clipboard, void,            (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, copy_clipboard, void,           (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, paste_clipboard, void,          (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, toggle_overwrite, void,         (void* text_view), 1, text_view);
-WRAPPER(GtkTextView2, move_focus, void,               (void* text_view, int direction), 2, text_view, direction);
+WRAPPER(GtkTextView2, set_scroll_adjustments, void,   (void* text_view, void* hadjustment, void* vadjustment), "ppp", text_view, hadjustment, vadjustment);
+WRAPPER(GtkTextView2, populate_popup, void,           (void* text_view, void* menu), "pp", text_view, menu);
+WRAPPER(GtkTextView2, move_cursor, void,              (void* text_view, int step, int count, int extend_selection), "piii", text_view, step, count, extend_selection);
+WRAPPER(GtkTextView2, page_horizontally, void,        (void* text_view, int count, int extend_selection), "pii", text_view, count, extend_selection);
+WRAPPER(GtkTextView2, set_anchor, void,               (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, insert_at_cursor, void,         (void* text_view, void* str), "pp", text_view, str);
+WRAPPER(GtkTextView2, delete_from_cursor, void,       (void* text_view, int type, int count), "pii", text_view, type, count);
+WRAPPER(GtkTextView2, backspace, void,                (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, cut_clipboard, void,            (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, copy_clipboard, void,           (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, paste_clipboard, void,          (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, toggle_overwrite, void,         (void* text_view), "p", text_view);
+WRAPPER(GtkTextView2, move_focus, void,               (void* text_view, int direction), "pi", text_view, direction);
 
 #define SUPERGO()                       \
     GO(set_scroll_adjustments, vFppp);  \
@@ -1948,7 +1948,7 @@ static void wrapGtkTextView2Class(my_GtkTextView2Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkTextView2Class(my_GtkTextView2Class_t* class)
-{   
+{
     unwrapGtkContainer2Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkTextView2 (class->A)
     SUPERGO()
@@ -1967,20 +1967,20 @@ static void bridgeGtkTextView2Class(my_GtkTextView2Class_t* class)
 
 // ----- GtkTextView3Class ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkTextView3, populate_popup, void,           (void* text_view, void* menu), 2, text_view, menu);
-WRAPPER(GtkTextView3, move_cursor, void,              (void* text_view, int step, int count, int extend_selection), 4, text_view, step, count, extend_selection);
-WRAPPER(GtkTextView3, set_anchor, void,               (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, insert_at_cursor, void,         (void* text_view, void* str), 2, text_view, str);
-WRAPPER(GtkTextView3, delete_from_cursor, void,       (void* text_view, int type, int count), 3, text_view, type, count);
-WRAPPER(GtkTextView3, backspace, void,                (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, cut_clipboard, void,            (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, copy_clipboard, void,           (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, paste_clipboard, void,          (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, toggle_overwrite, void,         (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, create_buffer, void*,           (void* text_view), 1, text_view);
-WRAPPER(GtkTextView3, draw_layer, void,               (void* text_view, int layer, void* cr), 3, text_view, layer, cr);
-WRAPPER(GtkTextView3, extend_selection, int,          (void* text_view, int granularity, void* location, void* start, void* end), 5, text_view, granularity, location, start, end);
-WRAPPER(GtkTextView3, insert_emoji, void,             (void* text_view), 1, text_view);
+WRAPPER(GtkTextView3, populate_popup, void,           (void* text_view, void* menu), "pp", text_view, menu);
+WRAPPER(GtkTextView3, move_cursor, void,              (void* text_view, int step, int count, int extend_selection), "piii", text_view, step, count, extend_selection);
+WRAPPER(GtkTextView3, set_anchor, void,               (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, insert_at_cursor, void,         (void* text_view, void* str), "pp", text_view, str);
+WRAPPER(GtkTextView3, delete_from_cursor, void,       (void* text_view, int type, int count), "pii", text_view, type, count);
+WRAPPER(GtkTextView3, backspace, void,                (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, cut_clipboard, void,            (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, copy_clipboard, void,           (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, paste_clipboard, void,          (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, toggle_overwrite, void,         (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, create_buffer, void*,           (void* text_view), "p", text_view);
+WRAPPER(GtkTextView3, draw_layer, void,               (void* text_view, int layer, void* cr), "pip", text_view, layer, cr);
+WRAPPER(GtkTextView3, extend_selection, int,          (void* text_view, int granularity, void* location, void* start, void* end), "pippp", text_view, granularity, location, start, end);
+WRAPPER(GtkTextView3, insert_emoji, void,             (void* text_view), "p", text_view);
 
 #define SUPERGO()                       \
     GO(populate_popup, vFpp);           \
@@ -2008,7 +2008,7 @@ static void wrapGtkTextView3Class(my_GtkTextView3Class_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGtkTextView3Class(my_GtkTextView3Class_t* class)
-{   
+{
     unwrapGtkContainer3Class(&class->parent_class);
     #define GO(A, W)   class->A = find_##A##_GtkTextView3 (class->A)
     SUPERGO()
@@ -2059,12 +2059,12 @@ static void bridgeGtkGrid3Class(my_GtkGrid3Class_t* class)
 
 // ----- GtkEventControllerClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkEventController, set_widget, void, (void* controller, void* widget), 2, controller, widget);
-WRAPPER(GtkEventController, unset_widget, void, (void* controller), 1, controller);
-WRAPPER(GtkEventController, handle_event, int, (void *controller, void *event, double x, double y), 4, controller, event, x, y);
-WRAPPER(GtkEventController, reset, void, (void* controller), 1, controller);
-WRAPPER(GtkEventController, handle_crossing, void, (void *controller, void *crossing, double x, double y), 4, controller, crossing, x, y);
-WRAPPER(GtkEventController, filter_event, void, (void *controller, void *event), 2, controller, event);
+WRAPPER(GtkEventController, set_widget, void, (void* controller, void* widget), "pp", controller, widget);
+WRAPPER(GtkEventController, unset_widget, void, (void* controller), "p", controller);
+WRAPPER(GtkEventController, handle_event, int, (void *controller, void *event, double x, double y), "ppdd", controller, event, x, y);
+WRAPPER(GtkEventController, reset, void, (void* controller), "p", controller);
+WRAPPER(GtkEventController, handle_crossing, void, (void *controller, void *crossing, double x, double y), "ppdd", controller, crossing, x, y);
+WRAPPER(GtkEventController, filter_event, void, (void *controller, void *event), "pp", controller, event);
 
 #define SUPERGO()               \
     GO(set_widget, vFpp);       \
@@ -2103,12 +2103,12 @@ static void bridgeGtkEventControllerClass(my_GtkEventControllerClass_t* class)
 
 // ----- GtkGestureClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkGesture, check, void, (void* gesture), 1, gesture);
-WRAPPER(GtkGesture, begin, void, (void *gesture, void *sequence), 2, gesture, sequence);
-WRAPPER(GtkGesture, update, void, (void *gesture, void *sequence), 2, gesture, sequence);
-WRAPPER(GtkGesture, end, void, (void *gesture, void *sequence), 2, gesture, sequence);
-WRAPPER(GtkGesture, cancel, void, (void *gesture, void *sequence), 2, gesture, sequence);
-WRAPPER(GtkGesture, sequence_state_changed, void, (void *gesture, void *sequence, int state), 3, gesture, sequence, state);
+WRAPPER(GtkGesture, check, void, (void* gesture), "p", gesture);
+WRAPPER(GtkGesture, begin, void, (void *gesture, void *sequence), "pp", gesture, sequence);
+WRAPPER(GtkGesture, update, void, (void *gesture, void *sequence), "pp", gesture, sequence);
+WRAPPER(GtkGesture, end, void, (void *gesture, void *sequence), "pp", gesture, sequence);
+WRAPPER(GtkGesture, cancel, void, (void *gesture, void *sequence), "pp", gesture, sequence);
+WRAPPER(GtkGesture, sequence_state_changed, void, (void *gesture, void *sequence, int state), "ppi", gesture, sequence, state);
 
 #define SUPERGO()              \
     GO(check, vFp);            \
@@ -2164,8 +2164,8 @@ static void bridgeGtkGestureSingleClass(my_GtkGestureSingleClass_t* class)
 
 // ----- GtkGestureClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GtkGestureLongPress, pressed, void, (void *gesture, double x, double y), 3, gesture, x, y);
-WRAPPER(GtkGestureLongPress, cancelled, void, (void *cancelled), 1, cancelled);
+WRAPPER(GtkGestureLongPress, pressed, void, (void *gesture, double x, double y), "pdd", gesture, x, y);
+WRAPPER(GtkGestureLongPress, cancelled, void, (void *cancelled), "p", cancelled);
 
 #define SUPERGO()              \
     GO(pressed, vFpdd);          \
@@ -2200,32 +2200,32 @@ static void bridgeGtkGestureLongPressClass(my_GtkGestureLongPressClass_t* class)
 
 // ----- AtkObjectClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(AtkObject, get_name, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_description, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_parent, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_n_children, int, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, ref_child, void*, (void* accessible, int i), 2, accessible, i);
-WRAPPER(AtkObject, get_index_in_parent, int, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, ref_relation_set, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_role, int, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_layer, int, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_mdi_zorder, int, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, ref_state_set, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, set_name, void, (void* accessible, void* name), 2, accessible, name);
-WRAPPER(AtkObject, set_description, void, (void* accessible, void* description), 2, accessible, description);
-WRAPPER(AtkObject, set_parent, void, (void* accessible, void* parent), 2, accessible, parent);
-WRAPPER(AtkObject, set_role, void, (void* accessible, int role), 2, accessible, role);
-WRAPPER(AtkObject, connect_property_change_handler, uint32_t, (void* accessible, void* handler), 2, accessible, AddCheckBridge(my_bridge, vFpp, handler, 0, NULL));
-WRAPPER(AtkObject, remove_property_change_handler, void, (void* accessible, uint32_t handler_id), 2, accessible, handler_id);
-WRAPPER(AtkObject, initialize, void, (void* accessible, void* data), 2, accessible, data);
-WRAPPER(AtkObject, children_changed, void, (void* accessible, uint32_t change_index, void* changed_child), 3, accessible, change_index, changed_child);
-WRAPPER(AtkObject, focus_event, void, (void* accessible, int focus_in), 2, accessible, focus_in);
-WRAPPER(AtkObject, property_change, void, (void* accessible, void* values), 2, accessible, values);
-WRAPPER(AtkObject, state_change, void, (void* accessible, void* name, int state_set), 3, accessible, name, state_set);
-WRAPPER(AtkObject, visible_data_changed, void, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, active_descendant_changed, void, (void* accessible, void* child), 2, accessible, child);
-WRAPPER(AtkObject, get_attributes, void*, (void* accessible), 1, accessible);
-WRAPPER(AtkObject, get_object_locale, void*, (void* accessible), 1, accessible);
+WRAPPER(AtkObject, get_name, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_description, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_parent, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_n_children, int, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, ref_child, void*, (void* accessible, int i), "pi", accessible, i);
+WRAPPER(AtkObject, get_index_in_parent, int, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, ref_relation_set, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_role, int, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_layer, int, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_mdi_zorder, int, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, ref_state_set, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, set_name, void, (void* accessible, void* name), "pp", accessible, name);
+WRAPPER(AtkObject, set_description, void, (void* accessible, void* description), "pp", accessible, description);
+WRAPPER(AtkObject, set_parent, void, (void* accessible, void* parent), "pp", accessible, parent);
+WRAPPER(AtkObject, set_role, void, (void* accessible, int role), "pi", accessible, role);
+WRAPPER(AtkObject, connect_property_change_handler, uint32_t, (void* accessible, void* handler), "pp", accessible, AddCheckBridge(my_bridge, vFpp, handler, 0, NULL));
+WRAPPER(AtkObject, remove_property_change_handler, void, (void* accessible, uint32_t handler_id), "pu", accessible, handler_id);
+WRAPPER(AtkObject, initialize, void, (void* accessible, void* data), "pp", accessible, data);
+WRAPPER(AtkObject, children_changed, void, (void* accessible, uint32_t change_index, void* changed_child), "pup", accessible, change_index, changed_child);
+WRAPPER(AtkObject, focus_event, void, (void* accessible, int focus_in), "pi", accessible, focus_in);
+WRAPPER(AtkObject, property_change, void, (void* accessible, void* values), "pp", accessible, values);
+WRAPPER(AtkObject, state_change, void, (void* accessible, void* name, int state_set), "ppi", accessible, name, state_set);
+WRAPPER(AtkObject, visible_data_changed, void, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, active_descendant_changed, void, (void* accessible, void* child), "pp", accessible, child);
+WRAPPER(AtkObject, get_attributes, void*, (void* accessible), "p", accessible);
+WRAPPER(AtkObject, get_object_locale, void*, (void* accessible), "p", accessible);
 
 #define SUPERGO() \
     GO(get_name, pFp);                          \
@@ -2265,7 +2265,7 @@ static void wrapAtkObjectClass(my_AtkObjectClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapAtkObjectClass(my_AtkObjectClass_t* class)
-{   
+{
     unwrapGObjectClass(&class->parent);
     #define GO(A, W)   class->A = find_##A##_AtkObject (class->A)
     SUPERGO()
@@ -2284,13 +2284,13 @@ static void bridgeAtkObjectClass(my_AtkObjectClass_t* class)
 
 // ----- AtkUtilClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(AtkUtil,add_global_event_listener, uint32_t,(void* listener, void* event_type), 2, AddCheckBridge(my_bridge, iFpupp, listener, 0, NULL), event_type);
-WRAPPER(AtkUtil,remove_global_event_listener, void ,(uint32_t listener_id), 1, listener_id);
-WRAPPER(AtkUtil,add_key_event_listener, uint32_t   ,(void* listener, void* data), 2, AddCheckBridge(my_bridge, iFpp, listener, 0, NULL), data);
-WRAPPER(AtkUtil,remove_key_event_listener, void    ,(uint32_t listener_id), 1, listener_id);
-WRAPPER(AtkUtil,get_root, void*                    ,(void), 0, 0);
-WRAPPER(AtkUtil,get_toolkit_name, void*            ,(void), 0, 0);
-WRAPPER(AtkUtil,get_toolkit_version, void*         ,(void), 0, 0);
+WRAPPER(AtkUtil,add_global_event_listener, uint32_t,(void* listener, void* event_type), "pp", AddCheckBridge(my_bridge, iFpupp, listener, 0, NULL), event_type);
+WRAPPER(AtkUtil,remove_global_event_listener, void ,(uint32_t listener_id), "u", listener_id);
+WRAPPER(AtkUtil,add_key_event_listener, uint32_t   ,(void* listener, void* data), "pp", AddCheckBridge(my_bridge, iFpp, listener, 0, NULL), data);
+WRAPPER(AtkUtil,remove_key_event_listener, void    ,(uint32_t listener_id), "u", listener_id);
+WRAPPER(AtkUtil,get_root, void*                    ,(void), "", 0);
+WRAPPER(AtkUtil,get_toolkit_name, void*            ,(void), "", 0);
+WRAPPER(AtkUtil,get_toolkit_version, void*         ,(void), "", 0);
 
 #define SUPERGO() \
     GO(add_global_event_listener, uFpp);        \
@@ -2311,7 +2311,7 @@ static void wrapAtkUtilClass(my_AtkUtilClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapAtkUtilClass(my_AtkUtilClass_t* class)
-{   
+{
     unwrapGObjectClass(&class->parent);
     #define GO(A, W)   class->A = find_##A##_AtkUtil (class->A)
     SUPERGO()
@@ -2330,7 +2330,7 @@ static void bridgeAtkUtilClass(my_AtkUtilClass_t* class)
 
 // ----- GstObjectClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GstObject, deep_notify, void, (void* object, void* origin, void* pspec), 3, object, origin, pspec);
+WRAPPER(GstObject, deep_notify, void, (void* object, void* origin, void* pspec), "ppp", object, origin, pspec);
 
 #define SUPERGO() \
     GO(deep_notify, vFppp); \
@@ -2345,7 +2345,7 @@ static void wrapGstObjectClass(my_GstObjectClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGstObjectClass(my_GstObjectClass_t* class)
-{   
+{
     unwrapGInitiallyUnownedClass(&class->parent);
     #define GO(A, W)   class->A = find_##A##_GstObject (class->A)
     SUPERGO()
@@ -2364,8 +2364,8 @@ static void bridgeGstObjectClass(my_GstObjectClass_t* class)
 
 // ----- GstAllocatorClass ------
 // wrapper x86 -> natives of callbacks
-WRAPPER(GstAllocator, alloc, void*, (void *allocator, size_t size, void *params), 3, allocator, size, params);
-WRAPPER(GstAllocator,free, void,    (void *allocator, void *memory), 2, allocator, memory);
+WRAPPER(GstAllocator, alloc, void*, (void *allocator, size_t size, void *params), "pLp", allocator, size, params);
+WRAPPER(GstAllocator,free, void,    (void *allocator, void *memory), "pp", allocator, memory);
 
 #define SUPERGO() \
     GO(alloc, pFpLp);       \
@@ -2381,7 +2381,7 @@ static void wrapGstAllocatorClass(my_GstAllocatorClass_t* class)
 }
 // unwrap (and use callback if not a native call anymore)
 static void unwrapGstAllocatorClass(my_GstAllocatorClass_t* class)
-{   
+{
     unwrapGstObjectClass(&class->parent);
     #define GO(A, W)   class->A = find_##A##_GstAllocator (class->A)
     SUPERGO()
@@ -2410,7 +2410,7 @@ static void wrapGTKClass(void* cl, size_t type)
     #define GTKCLASS(A)                             \
     if(type==my_##A)                                \
         wrap##A##Class((my_##A##Class_t*)cl);       \
-    else 
+    else
 
     printf_log(LOG_DEBUG, "wrapGTKClass(%p, %zd (%s))\n", cl, type, g_type_name(type));
     GTKCLASSES()
@@ -2429,7 +2429,7 @@ static void unwrapGTKClass(void* cl, size_t type)
     #define GTKCLASS(A)                             \
     if(type==my_##A)                                \
         unwrap##A##Class((my_##A##Class_t*)cl);     \
-    else 
+    else
 
     printf_log(LOG_DEBUG, "unwrapGTKClass(%p, %zd (%s))\n", cl, type, g_type_name(type));
     GTKCLASSES()
@@ -2442,7 +2442,7 @@ static void bridgeGTKClass(void* cl, size_t type)
     #define GTKCLASS(A)                             \
     if(type==my_##A)                                \
         bridge##A##Class((my_##A##Class_t*)cl);     \
-    else 
+    else
 
     printf_log(LOG_DEBUG, "bridgeGTKClass(%p, %zd (%s))\n", cl, type, g_type_name(type));
     GTKCLASSES()
@@ -2548,10 +2548,10 @@ SUPER()
 // Then the static functions callback that may be used with the structure
 // value_init ...
 #define GO(A)   \
-static uintptr_t my_value_init_fct_##A = 0;                 \
-static void my_value_init_##A(void* a)                      \
-{                                                           \
-    RunFunction(my_context, my_value_init_fct_##A, 1, a);   \
+static uintptr_t my_value_init_fct_##A = 0;                     \
+static void my_value_init_##A(void* a)                          \
+{                                                               \
+    RunFunctionFmt(my_context, my_value_init_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -2570,10 +2570,10 @@ static void* find_value_init_Fct(void* fct)
 }
 // value_free ...
 #define GO(A)   \
-static uintptr_t my_value_free_fct_##A = 0;                 \
-static void my_value_free_##A(void* a)                      \
-{                                                           \
-    RunFunction(my_context, my_value_free_fct_##A, 1, a);   \
+static uintptr_t my_value_free_fct_##A = 0;                     \
+static void my_value_free_##A(void* a)                          \
+{                                                               \
+    RunFunctionFmt(my_context, my_value_free_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -2592,10 +2592,10 @@ static void* find_value_free_Fct(void* fct)
 }
 // value_copy ...
 #define GO(A)   \
-static uintptr_t my_value_copy_fct_##A = 0;                 \
-static void my_value_copy_##A(void* a, void* b)             \
-{                                                           \
-    RunFunction(my_context, my_value_copy_fct_##A, 2, a, b);\
+static uintptr_t my_value_copy_fct_##A = 0;                     \
+static void my_value_copy_##A(void* a, void* b)                 \
+{                                                               \
+    RunFunctionFmt(my_context, my_value_copy_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -2614,10 +2614,10 @@ static void* find_value_copy_Fct(void* fct)
 }
 // value_peek_pointer ...
 #define GO(A)   \
-static uintptr_t my_value_peek_pointer_fct_##A = 0;                             \
-static void* my_value_peek_pointer_##A(void* a)                                 \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_value_peek_pointer_fct_##A, 1, a); \
+static uintptr_t my_value_peek_pointer_fct_##A = 0;                                 \
+static void* my_value_peek_pointer_##A(void* a)                                     \
+{                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_value_peek_pointer_fct_##A, "p", a);\
 }
 SUPER()
 #undef GO
@@ -2636,10 +2636,10 @@ static void* find_value_peek_pointer_Fct(void* fct)
 }
 // collect_value ...
 #define GO(A)   \
-static uintptr_t my_collect_value_fct_##A = 0;                                      \
-static void* my_collect_value_##A(void* a, uint32_t b, void* c, uint32_t d)         \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_collect_value_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_collect_value_fct_##A = 0;                                              \
+static void* my_collect_value_##A(void* a, uint32_t b, void* c, uint32_t d)                 \
+{                                                                                           \
+    return (void*)RunFunctionFmt(my_context, my_collect_value_fct_##A, "pupu", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -2658,10 +2658,10 @@ static void* find_collect_value_Fct(void* fct)
 }
 // lcopy_value ...
 #define GO(A)   \
-static uintptr_t my_lcopy_value_fct_##A = 0;                                      \
-static void* my_lcopy_value_##A(void* a, uint32_t b, void* c, uint32_t d)         \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_lcopy_value_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_lcopy_value_fct_##A = 0;                                                \
+static void* my_lcopy_value_##A(void* a, uint32_t b, void* c, uint32_t d)                   \
+{                                                                                           \
+    return (void*)RunFunctionFmt(my_context, my_lcopy_value_fct_##A, "pupu", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -2705,10 +2705,10 @@ my_GTypeValueTable_t* findFreeGTypeValueTable(my_GTypeValueTable_t* fcts)
 
 // signal2 ...
 #define GO(A)   \
-static uintptr_t my_signal2_fct_##A = 0;                                \
-static void* my_signal2_##A(void* a, void* b)                           \
-{                                                                       \
-    return (void*)RunFunction(my_context, my_signal2_fct_##A, 2, a, b); \
+static uintptr_t my_signal2_fct_##A = 0;                                        \
+static void* my_signal2_##A(void* a, void* b)                                   \
+{                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_signal2_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -2727,10 +2727,10 @@ static void* find_signal2_Fct(void* fct)
 }
 // signal3 ...
 #define GO(A)   \
-static uintptr_t my_signal3_fct_##A = 0;                                    \
-static void* my_signal3_##A(void* a, void* b, void* c)                      \
-{                                                                           \
-    return (void*)RunFunction(my_context, my_signal3_fct_##A, 3, a, b, c);  \
+static uintptr_t my_signal3_fct_##A = 0;                                            \
+static void* my_signal3_##A(void* a, void* b, void* c)                              \
+{                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_signal3_fct_##A, "ppp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -2749,10 +2749,10 @@ static void* find_signal3_Fct(void* fct)
 }
 // signal4 ...
 #define GO(A)   \
-static uintptr_t my_signal4_fct_##A = 0;                                        \
-static void* my_signal4_##A(void* a, void* b, void* c, void* d)                 \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_signal4_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_signal4_fct_##A = 0;                                                \
+static void* my_signal4_##A(void* a, void* b, void* c, void* d)                         \
+{                                                                                       \
+    return (void*)RunFunctionFmt(my_context, my_signal4_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -2771,10 +2771,10 @@ static void* find_signal4_Fct(void* fct)
 }
 // signal5 ...
 #define GO(A)   \
-static uintptr_t my_signal5_fct_##A = 0;                                        \
-static void* my_signal5_##A(void* a, void* b, void* c, void* d, void* e)        \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_signal5_fct_##A, 5, a, b, c, d, e);\
+static uintptr_t my_signal5_fct_##A = 0;                                                    \
+static void* my_signal5_##A(void* a, void* b, void* c, void* d, void* e)                    \
+{                                                                                           \
+    return (void*)RunFunctionFmt(my_context, my_signal5_fct_##A, "ppppp", a, b, c, d, e);   \
 }
 SUPER()
 #undef GO
@@ -2793,10 +2793,10 @@ static void* find_signal5_Fct(void* fct)
 }
 // signal6 ...
 #define GO(A)   \
-static uintptr_t my_signal6_fct_##A = 0;                                            \
-static void* my_signal6_##A(void* a, void* b, void* c, void* d, void* e, void* f)   \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_signal6_fct_##A, 6, a, b, c, d, e, f); \
+static uintptr_t my_signal6_fct_##A = 0;                                                        \
+static void* my_signal6_##A(void* a, void* b, void* c, void* d, void* e, void* f)               \
+{                                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_signal6_fct_##A, "pppppp", a, b, c, d, e, f);   \
 }
 SUPER()
 #undef GO
@@ -2815,10 +2815,10 @@ static void* find_signal6_Fct(void* fct)
 }
 // signal7 ...
 #define GO(A)   \
-static uintptr_t my_signal7_fct_##A = 0;                                            \
-static void* my_signal7_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g)  \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_signal7_fct_##A, 7, a, b, c, d, e, f, g);      \
+static uintptr_t my_signal7_fct_##A = 0;                                                            \
+static void* my_signal7_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g)          \
+{                                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_signal7_fct_##A, "ppppppp", a, b, c, d, e, f, g);   \
 }
 SUPER()
 #undef GO
@@ -2907,7 +2907,7 @@ SUPER()
 static uintptr_t my_base_init_fct_##A = 0;                          \
 static int my_base_init_##A(void* a)                                \
 {                                                                   \
-    return RunFunction(my_context, my_base_init_fct_##A, 1, a);     \
+    return RunFunctionFmt(my_context, my_base_init_fct_##A, "p", a);     \
 }
 SUPER()
 #undef GO
@@ -2929,7 +2929,7 @@ static void* find_base_init_Fct(void* fct)
 static uintptr_t my_base_finalize_fct_##A = 0;                      \
 static int my_base_finalize_##A(void* a)                            \
 {                                                                   \
-    return RunFunction(my_context, my_base_finalize_fct_##A, 1, a); \
+    return RunFunctionFmt(my_context, my_base_finalize_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -2948,21 +2948,21 @@ static void* find_base_finalize_Fct(void* fct)
 }
 // class_init ...
 #define GO(A)   \
-static uintptr_t my_class_init_fct_##A = 0;                             \
-static size_t parent_class_init_##A = 0;                                \
-static int my_class_init_##A(void* a, void* b)                          \
-{                                                                       \
+static uintptr_t my_class_init_fct_##A = 0;                                 \
+static size_t parent_class_init_##A = 0;                                    \
+static int my_class_init_##A(void* a, void* b)                              \
+{                                                                           \
     printf_log(LOG_DEBUG, "Custom Class init %d for class %p (parent=%p:%s)\n", A, a, (void*)parent_class_init_##A, g_type_name(parent_class_init_##A));\
-    int ret = RunFunction(my_context, my_class_init_fct_##A, 2, a, b);  \
-    unwrapGTKClass(a, parent_class_init_##A);                           \
-    bridgeGTKClass(a, parent_class_init_##A);                           \
-    my_unwrap_signal_offset(a);                                         \
-    if(!strcmp(g_type_name(parent_class_init_##A), "AtkUtil")) {        \
+    int ret = RunFunctionFmt(my_context, my_class_init_fct_##A, "pp", a, b);\
+    unwrapGTKClass(a, parent_class_init_##A);                               \
+    bridgeGTKClass(a, parent_class_init_##A);                               \
+    my_unwrap_signal_offset(a);                                             \
+    if(!strcmp(g_type_name(parent_class_init_##A), "AtkUtil")) {            \
         my_AtkUtilClass_t* p = (my_AtkUtilClass_t*)g_type_class_peek(parent_class_init_##A);\
-        unwrapGTKClass(p, parent_class_init_##A);                       \
-        bridgeGTKClass(p, parent_class_init_##A);                       \
-    }                                                                   \
-    return ret;                                                         \
+        unwrapGTKClass(p, parent_class_init_##A);                           \
+        bridgeGTKClass(p, parent_class_init_##A);                           \
+    }                                                                       \
+    return ret;                                                             \
 }
 SUPER()
 #undef GO
@@ -2981,10 +2981,10 @@ static void* find_class_init_Fct(void* fct, size_t parent)
 }
 // class_finalize ...
 #define GO(A)   \
-static uintptr_t my_class_finalize_fct_##A = 0;                         \
-static int my_class_finalize_##A(void* a, void* b)                      \
-{                                                                       \
-    return RunFunction(my_context, my_class_finalize_fct_##A, 2, a, b); \
+static uintptr_t my_class_finalize_fct_##A = 0;                                 \
+static int my_class_finalize_##A(void* a, void* b)                              \
+{                                                                               \
+    return RunFunctionFmt(my_context, my_class_finalize_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -3003,10 +3003,10 @@ static void* find_class_finalize_Fct(void* fct)
 }
 // instance_init ...
 #define GO(A)   \
-static uintptr_t my_instance_init_fct_##A = 0;                         \
-static int my_instance_init_##A(void* a, void* b)                      \
-{                                                                      \
-    return RunFunction(my_context, my_instance_init_fct_##A, 2, a, b); \
+static uintptr_t my_instance_init_fct_##A = 0;                              \
+static int my_instance_init_##A(void* a, void* b)                           \
+{                                                                           \
+    return RunFunctionFmt(my_context, my_instance_init_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -3066,20 +3066,20 @@ static int fct_gtk_parent_##A = 0 ;                 \
 static uintptr_t fct_gtk_class_init_##A = 0;        \
 static int my_gtk_class_init_##A(void* g_class) {   \
     printf_log(LOG_DEBUG, "Calling fct_gtk_class_init_" #A " wrapper\n");           \
-    int ret = (int)RunFunction(my_context, fct_gtk_class_init_##A, 1, g_class);     \
+    int ret = (int)RunFunctionFmt(my_context, fct_gtk_class_init_##A, "p", g_class);\
     unwrapGTKClass(g_class, fct_gtk_parent_##A);                                    \
     bridgeGTKClass(g_class, fct_gtk_parent_##A);                                    \
     return ret;                                                                     \
 }   \
-static uintptr_t fct_gtk_object_init_##A = 0;  \
-static int my_gtk_object_init_##A(void* object, void* data) {   \
-    printf_log(LOG_DEBUG, "Calling fct_gtk_object_init_" #A " wrapper\n");             \
-    return (int)RunFunction(my_context, fct_gtk_object_init_##A, 2, object, data);    \
+static uintptr_t fct_gtk_object_init_##A = 0;                                           \
+static int my_gtk_object_init_##A(void* object, void* data) {                           \
+    printf_log(LOG_DEBUG, "Calling fct_gtk_object_init_" #A " wrapper\n");              \
+    return (int)RunFunctionFmt(my_context, fct_gtk_object_init_##A, "pp", object, data);\
 }   \
-static uintptr_t fct_gtk_base_class_init_##A = 0;  \
-static int my_gtk_base_class_init_##A(void* instance, void* data) {   \
-    printf_log(LOG_DEBUG, "Calling fct_gtk_base_class_init_" #A " wrapper\n");             \
-    return (int)RunFunction(my_context, fct_gtk_base_class_init_##A, 2, instance, data);    \
+static uintptr_t fct_gtk_base_class_init_##A = 0;                                               \
+static int my_gtk_base_class_init_##A(void* instance, void* data) {                             \
+    printf_log(LOG_DEBUG, "Calling fct_gtk_base_class_init_" #A " wrapper\n");                  \
+    return (int)RunFunctionFmt(my_context, fct_gtk_base_class_init_##A, "pp", instance, data);  \
 }
 
 SUPER()
@@ -3195,7 +3195,7 @@ void my_signal_delete(my_signal_t* sig)
     }
     uintptr_t d = sig->destroy;
     if(d) {
-        RunFunction(my_context, d, 1, sig->data);
+        RunFunctionFmt(my_context, d, "p", sig->data);
     }
     printf_log(LOG_DEBUG, "gtk Data deleted, sig=%p, data=%p, destroy=%p\n", sig, sig->data, (void*)d);
     box_free(sig);
@@ -3237,10 +3237,10 @@ int my_signal_cb(void* a, void* b, void* c, void* d)
     }
     printf_log(LOG_DEBUG, "gtk Signal called, sig=%p, NArgs=%d\n", sig, i);
     switch(i) {
-        case 1: return (int)RunFunction(my_context, sig->c_handler, 1, sig->data);
-        case 2: return (int)RunFunction(my_context, sig->c_handler, 2, a, sig->data);
-        case 3: return (int)RunFunction(my_context, sig->c_handler, 3, a, b, sig->data);
-        case 4: return (int)RunFunction(my_context, sig->c_handler, 4, a, b, c, sig->data);
+        case 1: return (int)RunFunctionFmt(my_context, sig->c_handler, "p", sig->data);
+        case 2: return (int)RunFunctionFmt(my_context, sig->c_handler, "pp", a, sig->data);
+        case 3: return (int)RunFunctionFmt(my_context, sig->c_handler, "ppp", a, b, sig->data);
+        case 4: return (int)RunFunctionFmt(my_context, sig->c_handler, "pppp", a, b, c, sig->data);
     }
     printf_log(LOG_NONE, "Warning, Gtk signal callback but no data found!");
     return 0;
diff --git a/src/wrapped/wrappedd3dadapter9.c b/src/wrapped/wrappedd3dadapter9.c
index c43331dc..3629b52f 100644
--- a/src/wrapped/wrappedd3dadapter9.c
+++ b/src/wrapped/wrappedd3dadapter9.c
@@ -341,13 +341,13 @@ typedef struct my_Direct3D9Ex {
 unsigned my_Direct3D9Ex_AddRef(void *This)
 {
     my_Direct3D9Ex *my = This;
-    return RunFunction(my_context, (uintptr_t)(*my->real)->AddRef, 1, my->real);
+    return RunFunctionFmt(my_context, (uintptr_t)(*my->real)->AddRef, "p", my->real);
 }
 
 unsigned my_Direct3D9Ex_Release(void *This)
 {
     my_Direct3D9Ex *my = This;
-    return RunFunction(my_context, (uintptr_t)(*my->real)->Release, 1, my->real);
+    return RunFunctionFmt(my_context, (uintptr_t)(*my->real)->Release, "p", my->real);
 }
 
 IDirect3D9ExVtbl my_Direct3D9Ex_vtbl = {
diff --git a/src/wrapped/wrappeddbusglib1.c b/src/wrapped/wrappeddbusglib1.c
index b6680460..61597d6b 100755
--- a/src/wrapped/wrappeddbusglib1.c
+++ b/src/wrapped/wrappeddbusglib1.c
@@ -33,10 +33,10 @@ const char* dbusglib1Name = "libdbus-glib-1.so.2";
 
 // GDestroyNotify
 #define GO(A)   \
-static uintptr_t my_GDestroyNotify_fct_##A = 0;   \
-static void my_GDestroyNotify_##A(void* data)     \
-{                                       \
-    RunFunction(my_context, my_GDestroyNotify_fct_##A, 1, data);\
+static uintptr_t my_GDestroyNotify_fct_##A = 0;                         \
+static void my_GDestroyNotify_##A(void* data)                           \
+{                                                                       \
+    RunFunctionFmt(my_context, my_GDestroyNotify_fct_##A, "p", data);   \
 }
 SUPER()
 #undef GO
@@ -56,10 +56,10 @@ static void* findGDestroyNotifyFct(void* fct)
 
 // GClosureNotify
 #define GO(A)   \
-static uintptr_t my_GClosureNotify_fct_##A = 0;   \
-static void my_GClosureNotify_##A(void* data, void* closure)     \
-{                                       \
-    RunFunction(my_context, my_GClosureNotify_fct_##A, 2, data, closure);\
+static uintptr_t my_GClosureNotify_fct_##A = 0;                                 \
+static void my_GClosureNotify_##A(void* data, void* closure)                    \
+{                                                                               \
+    RunFunctionFmt(my_context, my_GClosureNotify_fct_##A, "pp", data, closure); \
 }
 SUPER()
 #undef GO
@@ -79,10 +79,10 @@ static void* findGClosureNotifyFct(void* fct)
 
 // DBusGProxyCallNotify
 #define GO(A)   \
-static uintptr_t my_DBusGProxyCallNotify_fct_##A = 0;   \
-static void my_DBusGProxyCallNotify_##A(void* proxy, void* call_id, void* data)     \
-{                                       \
-    RunFunction(my_context, my_DBusGProxyCallNotify_fct_##A, 3, proxy, call_id, data);\
+static uintptr_t my_DBusGProxyCallNotify_fct_##A = 0;                                           \
+static void my_DBusGProxyCallNotify_##A(void* proxy, void* call_id, void* data)                 \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_DBusGProxyCallNotify_fct_##A, "ppp", proxy, call_id, data);   \
 }
 SUPER()
 #undef GO
@@ -102,10 +102,10 @@ static void* findDBusGProxyCallNotifyFct(void* fct)
 
 // GCallback
 #define GO(A)   \
-static uintptr_t my_GCallback_fct_##A = 0;   \
-static void my_GCallback_##A(void* a, void* b, void* c, void* d)     \
-{                                       \
-    RunFunction(my_context, my_GCallback_fct_##A, 4, a, b, c, d);\
+static uintptr_t my_GCallback_fct_##A = 0;                                  \
+static void my_GCallback_##A(void* a, void* b, void* c, void* d)            \
+{                                                                           \
+    RunFunctionFmt(my_context, my_GCallback_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -125,10 +125,10 @@ static void* findGCallbackFct(void* fct)
 
 // DBusGTypeSpecializedCollectionIterator
 #define GO(A)   \
-static uintptr_t my_DBusGTypeSpecializedCollectionIterator_fct_##A = 0;                     \
-static void my_DBusGTypeSpecializedCollectionIterator_##A(void* a, void* b)                 \
-{                                                                                           \
-    RunFunction(my_context, my_DBusGTypeSpecializedCollectionIterator_fct_##A, 2, a, b);    \
+static uintptr_t my_DBusGTypeSpecializedCollectionIterator_fct_##A = 0;                         \
+static void my_DBusGTypeSpecializedCollectionIterator_##A(void* a, void* b)                     \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_DBusGTypeSpecializedCollectionIterator_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -147,10 +147,10 @@ static void* findDBusGTypeSpecializedCollectionIteratorFct(void* fct)
 }
 // DBusGTypeSpecializedMapIterator
 #define GO(A)   \
-static uintptr_t my_DBusGTypeSpecializedMapIterator_fct_##A = 0;                        \
-static void my_DBusGTypeSpecializedMapIterator_##A(void* a, void* b, void* c)           \
-{                                                                                       \
-    RunFunction(my_context, my_DBusGTypeSpecializedMapIterator_fct_##A, 3, a, b, c);    \
+static uintptr_t my_DBusGTypeSpecializedMapIterator_fct_##A = 0;                            \
+static void my_DBusGTypeSpecializedMapIterator_##A(void* a, void* b, void* c)               \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_DBusGTypeSpecializedMapIterator_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedexpat.c b/src/wrapped/wrappedexpat.c
index 4891e375..936a53ca 100755
--- a/src/wrapped/wrappedexpat.c
+++ b/src/wrapped/wrappedexpat.c
@@ -34,10 +34,10 @@ GO(4)
 
 // Start ...
 #define GO(A)   \
-static uintptr_t my_Start_fct_##A = 0;                                              \
-static void* my_Start_##A(void* data, void* name, void* attr)                       \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_Start_fct_##A, 3, data, name, attr);   \
+static uintptr_t my_Start_fct_##A = 0;                                                      \
+static void* my_Start_##A(void* data, void* name, void* attr)                               \
+{                                                                                           \
+    return (void*)RunFunctionFmt(my_context, my_Start_fct_##A, "ppp", data, name, attr);    \
 }
 SUPER()
 #undef GO
@@ -56,10 +56,10 @@ static void* find_Start_Fct(void* fct)
 }
 // End ...
 #define GO(A)   \
-static uintptr_t my_End_fct_##A = 0;                       \
-static void my_End_##A(void* data, void* name)             \
-{                                                          \
-    RunFunction(my_context, my_End_fct_##A, 2, data, name);\
+static uintptr_t my_End_fct_##A = 0;                                \
+static void my_End_##A(void* data, void* name)                      \
+{                                                                   \
+    RunFunctionFmt(my_context, my_End_fct_##A, "pp", data, name);   \
 }
 SUPER()
 #undef GO
@@ -78,10 +78,10 @@ static void* find_End_Fct(void* fct)
 }
 // CharData ...
 #define GO(A)   \
-static uintptr_t my_CharData_fct_##A = 0;                       \
-static void my_CharData_##A(void* data, void* s, int l)         \
-{                                                               \
-    RunFunction(my_context, my_CharData_fct_##A, 3, data, s, l);\
+static uintptr_t my_CharData_fct_##A = 0;                               \
+static void my_CharData_##A(void* data, void* s, int l)                 \
+{                                                                       \
+    RunFunctionFmt(my_context, my_CharData_fct_##A, "ppi", data, s, l); \
 }
 SUPER()
 #undef GO
@@ -100,10 +100,10 @@ static void* find_CharData_Fct(void* fct)
 }
 // StartNamespaceDecl ...
 #define GO(A)   \
-static uintptr_t my_StartNamespaceDecl_fct_##A = 0;                                 \
-static void my_StartNamespaceDecl_##A(void* data, void* name, void* attr)           \
-{                                                                               \
-    RunFunction(my_context, my_StartNamespaceDecl_fct_##A, 3, data, name, attr);    \
+static uintptr_t my_StartNamespaceDecl_fct_##A = 0;                                     \
+static void my_StartNamespaceDecl_##A(void* data, void* name, void* attr)               \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_StartNamespaceDecl_fct_##A, "ppp", data, name, attr); \
 }
 SUPER()
 #undef GO
@@ -122,10 +122,10 @@ static void* find_StartNamespaceDecl_Fct(void* fct)
 }
 // EndNamespaceDecl ...
 #define GO(A)   \
-static uintptr_t my_EndNamespaceDecl_fct_##A = 0;                       \
-static void my_EndNamespaceDecl_##A(void* data, void* name)             \
-{                                                          \
-    RunFunction(my_context, my_EndNamespaceDecl_fct_##A, 2, data, name);\
+static uintptr_t my_EndNamespaceDecl_fct_##A = 0;                               \
+static void my_EndNamespaceDecl_##A(void* data, void* name)                     \
+{                                                                               \
+    RunFunctionFmt(my_context, my_EndNamespaceDecl_fct_##A, "pp", data, name);  \
 }
 SUPER()
 #undef GO
@@ -144,10 +144,10 @@ static void* find_EndNamespaceDecl_Fct(void* fct)
 }
 // StartElement ...
 #define GO(A)   \
-static uintptr_t my_StartElement_fct_##A = 0;                                 \
-static void my_StartElement_##A(void* data, void* name, void* attr)           \
-{                                                                               \
-    RunFunction(my_context, my_StartElement_fct_##A, 3, data, name, attr);    \
+static uintptr_t my_StartElement_fct_##A = 0;                                       \
+static void my_StartElement_##A(void* data, void* name, void* attr)                 \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_StartElement_fct_##A, "ppp", data, name, attr);   \
 }
 SUPER()
 #undef GO
@@ -166,10 +166,10 @@ static void* find_StartElement_Fct(void* fct)
 }
 // EndElement ...
 #define GO(A)   \
-static uintptr_t my_EndElement_fct_##A = 0;                       \
-static void my_EndElement_##A(void* data, void* name)             \
-{                                                          \
-    RunFunction(my_context, my_EndElement_fct_##A, 2, data, name);\
+static uintptr_t my_EndElement_fct_##A = 0;                                 \
+static void my_EndElement_##A(void* data, void* name)                       \
+{                                                                           \
+    RunFunctionFmt(my_context, my_EndElement_fct_##A, "pp", data, name);    \
 }
 SUPER()
 #undef GO
@@ -188,10 +188,10 @@ static void* find_EndElement_Fct(void* fct)
 }
 // CharacterData ...
 #define GO(A)   \
-static uintptr_t my_CharacterData_fct_##A = 0;                              \
-static void my_CharacterData_##A(void* data, void* name, int len)           \
-{                                                                           \
-    RunFunction(my_context, my_CharacterData_fct_##A, 3, data, name, len);  \
+static uintptr_t my_CharacterData_fct_##A = 0;                                    \
+static void my_CharacterData_##A(void* data, void* name, int len)                 \
+{                                                                                 \
+    RunFunctionFmt(my_context, my_CharacterData_fct_##A, "ppi", data, name, len); \
 }
 SUPER()
 #undef GO
@@ -210,10 +210,10 @@ static void* find_CharacterData_Fct(void* fct)
 }
 // ProcessingInstruction ...
 #define GO(A)   \
-static uintptr_t my_ProcessingInstruction_fct_##A = 0;                      \
-static void my_ProcessingInstruction_##A(void* a, void* b, void* c)         \
-{                                                                           \
-    RunFunction(my_context, my_ProcessingInstruction_fct_##A, 3, a, b, c);  \
+static uintptr_t my_ProcessingInstruction_fct_##A = 0;                            \
+static void my_ProcessingInstruction_##A(void* a, void* b, void* c)               \
+{                                                                                 \
+    RunFunctionFmt(my_context, my_ProcessingInstruction_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -232,10 +232,10 @@ static void* find_ProcessingInstruction_Fct(void* fct)
 }
 // Comment ...
 #define GO(A)   \
-static uintptr_t my_Comment_fct_##A = 0;                    \
-static void my_Comment_##A(void* a, void* b)                \
-{                                                           \
-    RunFunction(my_context, my_Comment_fct_##A, 2, a, b);   \
+static uintptr_t my_Comment_fct_##A = 0;                        \
+static void my_Comment_##A(void* a, void* b)                    \
+{                                                               \
+    RunFunctionFmt(my_context, my_Comment_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -254,10 +254,10 @@ static void* find_Comment_Fct(void* fct)
 }
 // StartCdataSection ...
 #define GO(A)   \
-static uintptr_t my_StartCdataSection_fct_##A = 0;                     \
-static void my_StartCdataSection_##A(void* data)                       \
-{                                                                      \
-    RunFunction(my_context, my_StartCdataSection_fct_##A, 1, data);    \
+static uintptr_t my_StartCdataSection_fct_##A = 0;                       \
+static void my_StartCdataSection_##A(void* data)                         \
+{                                                                        \
+    RunFunctionFmt(my_context, my_StartCdataSection_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -276,10 +276,10 @@ static void* find_StartCdataSection_Fct(void* fct)
 }
 // EndCdataSection ...
 #define GO(A)   \
-static uintptr_t my_EndCdataSection_fct_##A = 0;                   \
-static void my_EndCdataSection_##A(void* data)                     \
-{                                                                  \
-    RunFunction(my_context, my_EndCdataSection_fct_##A, 1, data);  \
+static uintptr_t my_EndCdataSection_fct_##A = 0;                       \
+static void my_EndCdataSection_##A(void* data)                         \
+{                                                                      \
+    RunFunctionFmt(my_context, my_EndCdataSection_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -298,10 +298,10 @@ static void* find_EndCdataSection_Fct(void* fct)
 }
 // Default ...
 #define GO(A)   \
-static uintptr_t my_Default_fct_##A = 0;                              \
-static void my_Default_##A(void* data, void* name, int len)           \
-{                                                                     \
-    RunFunction(my_context, my_Default_fct_##A, 3, data, name, len);  \
+static uintptr_t my_Default_fct_##A = 0;                                    \
+static void my_Default_##A(void* data, void* name, int len)                 \
+{                                                                           \
+    RunFunctionFmt(my_context, my_Default_fct_##A, "ppi", data, name, len); \
 }
 SUPER()
 #undef GO
@@ -320,10 +320,10 @@ static void* find_Default_Fct(void* fct)
 }
 // StartDoctypeDecl ...
 #define GO(A)   \
-static uintptr_t my_StartDoctypeDecl_fct_##A = 0;                               \
-static void my_StartDoctypeDecl_##A(void* a, void* b, void* c, void* d, int e)  \
-{                                                                               \
-    RunFunction(my_context, my_StartDoctypeDecl_fct_##A, 5, a, b, c, d, e);     \
+static uintptr_t my_StartDoctypeDecl_fct_##A = 0;                                    \
+static void my_StartDoctypeDecl_##A(void* a, void* b, void* c, void* d, int e)       \
+{                                                                                    \
+    RunFunctionFmt(my_context, my_StartDoctypeDecl_fct_##A, "ppppi", a, b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -342,10 +342,10 @@ static void* find_StartDoctypeDecl_Fct(void* fct)
 }
 // EndDoctypeDecl ...
 #define GO(A)   \
-static uintptr_t my_EndDoctypeDecl_fct_##A = 0;                     \
-static void my_EndDoctypeDecl_##A(void* data)                       \
-{                                                                   \
-    RunFunction(my_context, my_EndDoctypeDecl_fct_##A, 1, data);    \
+static uintptr_t my_EndDoctypeDecl_fct_##A = 0;                       \
+static void my_EndDoctypeDecl_##A(void* data)                         \
+{                                                                     \
+    RunFunctionFmt(my_context, my_EndDoctypeDecl_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -364,10 +364,10 @@ static void* find_EndDoctypeDecl_Fct(void* fct)
 }
 // EntityDecl ...
 #define GO(A)   \
-static uintptr_t my_EntityDecl_fct_##A = 0;                                                                 \
-static void my_EntityDecl_##A(void* a, void* b, int c, void* d, int e, void* f, void* g, void* h, void* i)  \
-{                                                                                                           \
-    RunFunction(my_context, my_EntityDecl_fct_##A, 9, a, b, c, d, e, f, g, h, i);                           \
+static uintptr_t my_EntityDecl_fct_##A = 0;                                                                \
+static void my_EntityDecl_##A(void* a, void* b, int c, void* d, int e, void* f, void* g, void* h, void* i) \
+{                                                                                                          \
+    RunFunctionFmt(my_context, my_EntityDecl_fct_##A, "ppipipppp", a, b, c, d, e, f, g, h, i);             \
 }
 SUPER()
 #undef GO
@@ -386,10 +386,10 @@ static void* find_EntityDecl_Fct(void* fct)
 }
 // ElementDecl ...
 #define GO(A)   \
-static uintptr_t my_ElementDecl_fct_##A = 0;                        \
-static void my_ElementDecl_##A(void* a, void* b, void* c)           \
-{                                                                   \
-    RunFunction(my_context, my_ElementDecl_fct_##A, 3, a, b, c);    \
+static uintptr_t my_ElementDecl_fct_##A = 0;                            \
+static void my_ElementDecl_##A(void* a, void* b, void* c)               \
+{                                                                       \
+    RunFunctionFmt(my_context, my_ElementDecl_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -408,10 +408,10 @@ static void* find_ElementDecl_Fct(void* fct)
 }
 // UnknownEncoding ...
 #define GO(A)   \
-static uintptr_t my_UnknownEncoding_fct_##A = 0;                                    \
-static int my_UnknownEncoding_##A(void* a, void* b, void* c)                        \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_UnknownEncoding_fct_##A, 3, a, b, c);    \
+static uintptr_t my_UnknownEncoding_fct_##A = 0;                                        \
+static int my_UnknownEncoding_##A(void* a, void* b, void* c)                            \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_UnknownEncoding_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -433,7 +433,7 @@ static void* find_UnknownEncoding_Fct(void* fct)
 static uintptr_t my_UnparsedEntityDecl_fct_##A = 0;                                         \
 static void my_UnparsedEntityDecl_##A(void* a, void* b, void* c, void* d, void* e, void* f) \
 {                                                                                           \
-    RunFunction(my_context, my_UnparsedEntityDecl_fct_##A, 6, a, b, c, d, e, f);            \
+    RunFunctionFmt(my_context, my_UnparsedEntityDecl_fct_##A, "pppppp", a, b, c, d, e, f);  \
 }
 SUPER()
 #undef GO
@@ -452,10 +452,10 @@ static void* find_UnparsedEntityDecl_Fct(void* fct)
 }
 // NotationDecl ...
 #define GO(A)   \
-static uintptr_t my_NotationDecl_fct_##A = 0;                                   \
-static void my_NotationDecl_##A(void* a, void* b, void* c, void* d, void* e)    \
-{                                                                               \
-    RunFunction(my_context, my_NotationDecl_fct_##A, 5, a, b, c, d, e);         \
+static uintptr_t my_NotationDecl_fct_##A = 0;                                    \
+static void my_NotationDecl_##A(void* a, void* b, void* c, void* d, void* e)     \
+{                                                                                \
+    RunFunctionFmt(my_context, my_NotationDecl_fct_##A, "ppppp", a, b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -474,10 +474,10 @@ static void* find_NotationDecl_Fct(void* fct)
 }
 // NotStandalone ...
 #define GO(A)   \
-static uintptr_t my_NotStandalone_fct_##A = 0;                              \
-static int my_NotStandalone_##A(void* data)                                 \
-{                                                                           \
-    return (int)RunFunction(my_context, my_NotStandalone_fct_##A, 1, data); \
+static uintptr_t my_NotStandalone_fct_##A = 0;                                   \
+static int my_NotStandalone_##A(void* data)                                      \
+{                                                                                \
+    return (int)RunFunctionFmt(my_context, my_NotStandalone_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -496,10 +496,10 @@ static void* find_NotStandalone_Fct(void* fct)
 }
 // ExternalEntityRef ...
 #define GO(A)   \
-static uintptr_t my_ExternalEntityRef_fct_##A = 0;                                          \
-static int my_ExternalEntityRef_##A(void* a, void* b, void* c, void* d, void* e)            \
-{                                                                                           \
-    return (int)RunFunction(my_context, my_ExternalEntityRef_fct_##A, 5, a, b, c, d, e);    \
+static uintptr_t my_ExternalEntityRef_fct_##A = 0;                                                \
+static int my_ExternalEntityRef_##A(void* a, void* b, void* c, void* d, void* e)                  \
+{                                                                                                 \
+    return (int)RunFunctionFmt(my_context, my_ExternalEntityRef_fct_##A, "ppppp", a, b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -518,10 +518,10 @@ static void* find_ExternalEntityRef_Fct(void* fct)
 }
 // XmlDecl ...
 #define GO(A)   \
-static uintptr_t my_XmlDecl_fct_##A = 0;                        \
-static void my_XmlDecl_##A(void* a, void* b, void* c, int d)    \
-{                                                               \
-    RunFunction(my_context, my_XmlDecl_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_XmlDecl_fct_##A = 0;                                \
+static void my_XmlDecl_##A(void* a, void* b, void* c, int d)            \
+{                                                                       \
+    RunFunctionFmt(my_context, my_XmlDecl_fct_##A, "pppi", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -543,7 +543,7 @@ static void* find_XmlDecl_Fct(void* fct)
 static uintptr_t my_AttlistDecl_fct_##A = 0;                                        \
 static void my_AttlistDecl_##A(void* a, void* b, void* c, void* d, void* e, int f)  \
 {                                                                                   \
-    RunFunction(my_context, my_AttlistDecl_fct_##A, 6, a, b, c, d, e, f);           \
+    RunFunctionFmt(my_context, my_AttlistDecl_fct_##A, "pppppi", a, b, c, d, e, f); \
 }
 SUPER()
 #undef GO
@@ -562,10 +562,10 @@ static void* find_AttlistDecl_Fct(void* fct)
 }
 // SkippedEntity ...
 #define GO(A)   \
-static uintptr_t my_SkippedEntity_fct_##A = 0;                      \
-static void my_SkippedEntity_##A(void* a, void* b, int c)           \
-{                                                                   \
-    RunFunction(my_context, my_SkippedEntity_fct_##A, 3, a, b, c);  \
+static uintptr_t my_SkippedEntity_fct_##A = 0;                            \
+static void my_SkippedEntity_##A(void* a, void* b, int c)                 \
+{                                                                         \
+    RunFunctionFmt(my_context, my_SkippedEntity_fct_##A, "ppi", a, b, c); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedfaudio.c b/src/wrapped/wrappedfaudio.c
index ae4d3379..13435027 100644
--- a/src/wrapped/wrappedfaudio.c
+++ b/src/wrapped/wrappedfaudio.c
@@ -34,10 +34,10 @@ GO(4)
 
 // FAudioMalloc ...
 #define GO(A)   \
-static uintptr_t my_FAudioMalloc_fct_##A = 0;                               \
-static void* my_FAudioMalloc_##A(size_t a)                                  \
-{                                                                           \
-    return (void*)RunFunction(my_context, my_FAudioMalloc_fct_##A, 1, a);   \
+static uintptr_t my_FAudioMalloc_fct_##A = 0;                                  \
+static void* my_FAudioMalloc_##A(size_t a)                                     \
+{                                                                              \
+    return (void*)RunFunctionFmt(my_context, my_FAudioMalloc_fct_##A, "L", a); \
 }
 SUPER()
 #undef GO
@@ -56,10 +56,10 @@ static void* find_FAudioMalloc_Fct(void* fct)
 }
 // FAudioFree ...
 #define GO(A)   \
-static uintptr_t my_FAudioFree_fct_##A = 0;                 \
-static void my_FAudioFree_##A(void* a)                      \
-{                                                           \
-    RunFunction(my_context, my_FAudioFree_fct_##A, 1, a);   \
+static uintptr_t my_FAudioFree_fct_##A = 0;                    \
+static void my_FAudioFree_##A(void* a)                         \
+{                                                              \
+    RunFunctionFmt(my_context, my_FAudioFree_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -78,10 +78,10 @@ static void* find_FAudioFree_Fct(void* fct)
 }
 // FAudioRealloc ...
 #define GO(A)   \
-static uintptr_t my_FAudioRealloc_fct_##A = 0;                                  \
-static void* my_FAudioRealloc_##A(void* a, size_t b)                            \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_FAudioRealloc_fct_##A, 2, a, b);   \
+static uintptr_t my_FAudioRealloc_fct_##A = 0;                                      \
+static void* my_FAudioRealloc_##A(void* a, size_t b)                                \
+{                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_FAudioRealloc_fct_##A, "pL", a, b); \
 }
 SUPER()
 #undef GO
@@ -100,10 +100,10 @@ static void* find_FAudioRealloc_Fct(void* fct)
 }
 // OnCriticalErrorFunc ...
 #define GO(A)   \
-static uintptr_t my_OnCriticalErrorFunc_fct_##A = 0;                    \
-static void my_OnCriticalErrorFunc_##A(void* a, uint32_t b)             \
-{                                                                       \
-    RunFunction(my_context, my_OnCriticalErrorFunc_fct_##A, 2, a, b);   \
+static uintptr_t my_OnCriticalErrorFunc_fct_##A = 0;                        \
+static void my_OnCriticalErrorFunc_##A(void* a, uint32_t b)                 \
+{                                                                           \
+    RunFunctionFmt(my_context, my_OnCriticalErrorFunc_fct_##A, "pu", a, b); \
 }
 SUPER()
 #undef GO
@@ -122,10 +122,10 @@ static void* find_OnCriticalErrorFunc_Fct(void* fct)
 }
 // OnProcessingPassEndFunc ...
 #define GO(A)   \
-static uintptr_t my_OnProcessingPassEndFunc_fct_##A = 0;                \
-static void my_OnProcessingPassEndFunc_##A(void* a)                     \
-{                                                                       \
-    RunFunction(my_context, my_OnProcessingPassEndFunc_fct_##A, 1, a);  \
+static uintptr_t my_OnProcessingPassEndFunc_fct_##A = 0;                    \
+static void my_OnProcessingPassEndFunc_##A(void* a)                         \
+{                                                                           \
+    RunFunctionFmt(my_context, my_OnProcessingPassEndFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -144,10 +144,10 @@ static void* find_OnProcessingPassEndFunc_Fct(void* fct)
 }
 // OnProcessingPassStartFunc ...
 #define GO(A)   \
-static uintptr_t my_OnProcessingPassStartFunc_fct_##A = 0;                \
-static void my_OnProcessingPassStartFunc_##A(void* a)                     \
-{                                                                       \
-    RunFunction(my_context, my_OnProcessingPassStartFunc_fct_##A, 1, a);  \
+static uintptr_t my_OnProcessingPassStartFunc_fct_##A = 0;                    \
+static void my_OnProcessingPassStartFunc_##A(void* a)                         \
+{                                                                             \
+    RunFunctionFmt(my_context, my_OnProcessingPassStartFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -172,10 +172,10 @@ typedef struct my_FAudioEngineCallback_s
 } my_FAudioEngineCallback_t;
 // OnBufferEndFunc ...
 #define GO(A)   \
-static uintptr_t my_OnBufferEndFunc_fct_##A = 0;                    \
-static void my_OnBufferEndFunc_##A(void* a, void* b)                \
-{                                                                   \
-    RunFunction(my_context, my_OnBufferEndFunc_fct_##A, 2, a, b);   \
+static uintptr_t my_OnBufferEndFunc_fct_##A = 0;                        \
+static void my_OnBufferEndFunc_##A(void* a, void* b)                    \
+{                                                                       \
+    RunFunctionFmt(my_context, my_OnBufferEndFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -194,10 +194,10 @@ static void* find_OnBufferEndFunc_Fct(void* fct)
 }
 // OnBufferStartFunc ...
 #define GO(A)   \
-static uintptr_t my_OnBufferStartFunc_fct_##A = 0;                    \
-static void my_OnBufferStartFunc_##A(void* a, void* b)                \
-{                                                                   \
-    RunFunction(my_context, my_OnBufferStartFunc_fct_##A, 2, a, b);   \
+static uintptr_t my_OnBufferStartFunc_fct_##A = 0;                        \
+static void my_OnBufferStartFunc_##A(void* a, void* b)                    \
+{                                                                         \
+    RunFunctionFmt(my_context, my_OnBufferStartFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -216,10 +216,10 @@ static void* find_OnBufferStartFunc_Fct(void* fct)
 }
 // OnLoopEndFunc ...
 #define GO(A)   \
-static uintptr_t my_OnLoopEndFunc_fct_##A = 0;                    \
-static void my_OnLoopEndFunc_##A(void* a, void* b)                \
-{                                                                   \
-    RunFunction(my_context, my_OnLoopEndFunc_fct_##A, 2, a, b);   \
+static uintptr_t my_OnLoopEndFunc_fct_##A = 0;                        \
+static void my_OnLoopEndFunc_##A(void* a, void* b)                    \
+{                                                                     \
+    RunFunctionFmt(my_context, my_OnLoopEndFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -238,10 +238,10 @@ static void* find_OnLoopEndFunc_Fct(void* fct)
 }
 // OnStreamEndFunc ...
 #define GO(A)   \
-static uintptr_t my_OnStreamEndFunc_fct_##A = 0;                \
-static void my_OnStreamEndFunc_##A(void* a)                     \
-{                                                               \
-    RunFunction(my_context, my_OnStreamEndFunc_fct_##A, 1, a);  \
+static uintptr_t my_OnStreamEndFunc_fct_##A = 0;                    \
+static void my_OnStreamEndFunc_##A(void* a)                         \
+{                                                                   \
+    RunFunctionFmt(my_context, my_OnStreamEndFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -260,10 +260,10 @@ static void* find_OnStreamEndFunc_Fct(void* fct)
 }
 // OnVoiceErrorFunc ...
 #define GO(A)   \
-static uintptr_t my_OnVoiceErrorFunc_fct_##A = 0;                       \
-static void my_OnVoiceErrorFunc_##A(void* a, void* b, uint32_t c)       \
-{                                                                       \
-    RunFunction(my_context, my_OnVoiceErrorFunc_fct_##A, 3, a, b, c);   \
+static uintptr_t my_OnVoiceErrorFunc_fct_##A = 0;                            \
+static void my_OnVoiceErrorFunc_##A(void* a, void* b, uint32_t c)            \
+{                                                                            \
+    RunFunctionFmt(my_context, my_OnVoiceErrorFunc_fct_##A, "ppu", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -282,10 +282,10 @@ static void* find_OnVoiceErrorFunc_Fct(void* fct)
 }
 // OnVoiceProcessingPassEndFunc ...
 #define GO(A)   \
-static uintptr_t my_OnVoiceProcessingPassEndFunc_fct_##A = 0;                \
-static void my_OnVoiceProcessingPassEndFunc_##A(void* a)                     \
-{                                                               \
-    RunFunction(my_context, my_OnVoiceProcessingPassEndFunc_fct_##A, 1, a);  \
+static uintptr_t my_OnVoiceProcessingPassEndFunc_fct_##A = 0;                    \
+static void my_OnVoiceProcessingPassEndFunc_##A(void* a)                         \
+{                                                                                \
+    RunFunctionFmt(my_context, my_OnVoiceProcessingPassEndFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -304,10 +304,10 @@ static void* find_OnVoiceProcessingPassEndFunc_Fct(void* fct)
 }
 // OnVoiceProcessingPassStartFunc ...
 #define GO(A)   \
-static uintptr_t my_OnVoiceProcessingPassStartFunc_fct_##A = 0;                     \
-static void my_OnVoiceProcessingPassStartFunc_##A(void* a, uint32_t b)              \
-{                                                                                   \
-    RunFunction(my_context, my_OnVoiceProcessingPassStartFunc_fct_##A, 2, a, b);    \
+static uintptr_t my_OnVoiceProcessingPassStartFunc_fct_##A = 0;                        \
+static void my_OnVoiceProcessingPassStartFunc_##A(void* a, uint32_t b)                 \
+{                                                                                      \
+    RunFunctionFmt(my_context, my_OnVoiceProcessingPassStartFunc_fct_##A, "pu", a, b); \
 }
 SUPER()
 #undef GO
@@ -336,10 +336,10 @@ typedef struct my_FAudioVoiceCallback_s
 } my_FAudioVoiceCallback_t;
 // FAudioEngineCallEXT ...
 #define GO(A)   \
-static uintptr_t my_FAudioEngineCallEXT_fct_##A = 0;                    \
-static void my_FAudioEngineCallEXT_##A(void* a, void* b)                \
-{                                                                       \
-    RunFunction(my_context, my_FAudioEngineCallEXT_fct_##A, 2, a, b);   \
+static uintptr_t my_FAudioEngineCallEXT_fct_##A = 0;                        \
+static void my_FAudioEngineCallEXT_##A(void* a, void* b)                    \
+{                                                                           \
+    RunFunctionFmt(my_context, my_FAudioEngineCallEXT_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -358,10 +358,10 @@ static void* find_FAudioEngineCallEXT_Fct(void* fct)
 }
 // FAudioEngineProcedureEXT ...
 #define GO(A)   \
-static uintptr_t my_FAudioEngineProcedureEXT_fct_##A = 0;                                                       \
-static void my_FAudioEngineProcedureEXT_##A(void* a, void* b, void* c, void* d)                                 \
-{                                                                                                               \
-    RunFunction(my_context, my_FAudioEngineProcedureEXT_fct_##A, 4, find_FAudioEngineCallEXT_Fct(a), b, c, d);  \
+static uintptr_t my_FAudioEngineProcedureEXT_fct_##A = 0;                                                              \
+static void my_FAudioEngineProcedureEXT_##A(void* a, void* b, void* c, void* d)                                        \
+{                                                                                                                      \
+    RunFunctionFmt(my_context, my_FAudioEngineProcedureEXT_fct_##A, "pppp", find_FAudioEngineCallEXT_Fct(a), b, c, d); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedflac.c b/src/wrapped/wrappedflac.c
index 4bff742f..45e8b059 100755
--- a/src/wrapped/wrappedflac.c
+++ b/src/wrapped/wrappedflac.c
@@ -51,10 +51,10 @@ GO(7)
 
 // read_write
 #define GO(A)   \
-static uintptr_t my_read_write_fct_##A = 0;   \
-static unsigned long my_read_write_##A(void* ptr, unsigned long size, unsigned long nmemb, void* handle)     \
-{                                       \
-    return RunFunction(my_context, my_read_write_fct_##A, 4, ptr, size, nmemb, handle);\
+static uintptr_t my_read_write_fct_##A = 0;                                                              \
+static unsigned long my_read_write_##A(void* ptr, unsigned long size, unsigned long nmemb, void* handle) \
+{                                                                                                        \
+    return RunFunctionFmt(my_context, my_read_write_fct_##A, "pLLp", ptr, size, nmemb, handle);          \
 }
 SUPER()
 #undef GO
@@ -73,10 +73,10 @@ static void* findread_writeFct(void* fct)
 }
 // seek
 #define GO(A)   \
-static uintptr_t my_seek_fct_##A = 0;   \
-static int my_seek_##A(void* ptr, int64_t offset, int whence)     \
-{                                       \
-    return (int)RunFunction(my_context, my_seek_fct_##A, 3, ptr, offset, whence);\
+static uintptr_t my_seek_fct_##A = 0;                                                    \
+static int my_seek_##A(void* ptr, int64_t offset, int whence)                            \
+{                                                                                        \
+    return (int)RunFunctionFmt(my_context, my_seek_fct_##A, "pIi", ptr, offset, whence); \
 }
 SUPER()
 #undef GO
@@ -95,10 +95,10 @@ static void* findseekFct(void* fct)
 }
 // close_eof
 #define GO(A)   \
-static uintptr_t my_close_eof_fct_##A = 0;   \
-static int my_close_eof_##A(void* ptr)     \
-{                   \
-    return (int)RunFunction(my_context, my_close_eof_fct_##A, 1, ptr);\
+static uintptr_t my_close_eof_fct_##A = 0;                                  \
+static int my_close_eof_##A(void* ptr)                                      \
+{                                                                           \
+    return (int)RunFunctionFmt(my_context, my_close_eof_fct_##A, "p", ptr); \
 }
 SUPER()
 #undef GO
@@ -117,10 +117,10 @@ static void* findclose_eofFct(void* fct)
 }
 // tell
 #define GO(A)   \
-static uintptr_t my_tell_fct_##A = 0;   \
-static long my_tell_##A(void* ptr)     \
-{                                       \
-    return (long)RunFunction(my_context, my_tell_fct_##A, 1, ptr);\
+static uintptr_t my_tell_fct_##A = 0;                                   \
+static long my_tell_##A(void* ptr)                                      \
+{                                                                       \
+    return (long)RunFunctionFmt(my_context, my_tell_fct_##A, "p", ptr); \
 }
 SUPER()
 #undef GO
@@ -138,11 +138,11 @@ static void* findtellFct(void* fct)
     return NULL;
 }
 // Read
-#define GO(A)                                                                               \
-static uintptr_t my_Read_fct_##A = 0;                                                       \
-static int my_Read_##A(void* decoder, void* buffer, size_t* bytes, void* data)              \
-{                                                                                           \
-    return (int)RunFunction(my_context, my_Read_fct_##A, 4, decoder, buffer, bytes, data);  \
+#define GO(A)   \
+static uintptr_t my_Read_fct_##A = 0;                                                              \
+static int my_Read_##A(void* decoder, void* buffer, size_t* bytes, void* data)                     \
+{                                                                                                  \
+    return (int)RunFunctionFmt(my_context, my_Read_fct_##A, "pppp", decoder, buffer, bytes, data); \
 }
 SUPER()
 #undef GO
@@ -160,11 +160,11 @@ static void* findReadFct(void* fct)
     return NULL;
 }
 // Seek
-#define GO(A)                                                                       \
-static uintptr_t my_Seek_fct_##A = 0;                                               \
-static int my_Seek_##A(void* decoder, uint64_t offset, void* data)                  \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_Seek_fct_##A, 3, decoder, offset, data); \
+#define GO(A)   \
+static uintptr_t my_Seek_fct_##A = 0;                                                      \
+static int my_Seek_##A(void* decoder, uint64_t offset, void* data)                         \
+{                                                                                          \
+    return (int)RunFunctionFmt(my_context, my_Seek_fct_##A, "pUp", decoder, offset, data); \
 }
 SUPER()
 #undef GO
@@ -182,11 +182,11 @@ static void* findSeekFct(void* fct)
     return NULL;
 }
 // Tell
-#define GO(A)                                                                       \
-static uintptr_t my_Tell_fct_##A = 0;                                               \
-static int my_Tell_##A(void* decoder, uint64_t *offset, void* data)                 \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_Tell_fct_##A, 3, decoder, offset, data); \
+#define GO(A)   \
+static uintptr_t my_Tell_fct_##A = 0;                                                      \
+static int my_Tell_##A(void* decoder, uint64_t *offset, void* data)                        \
+{                                                                                          \
+    return (int)RunFunctionFmt(my_context, my_Tell_fct_##A, "ppp", decoder, offset, data); \
 }
 SUPER()
 #undef GO
@@ -204,11 +204,11 @@ static void* findTellFct(void* fct)
     return NULL;
 }
 // Length
-#define GO(A)                                                                           \
-static uintptr_t my_Length_fct_##A = 0;                                                 \
-static int my_Length_##A(void* decoder, uint64_t *length, void* data)                   \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_Length_fct_##A, 3, decoder, length, data);   \
+#define GO(A)                                                                                \
+static uintptr_t my_Length_fct_##A = 0;                                                      \
+static int my_Length_##A(void* decoder, uint64_t *length, void* data)                        \
+{                                                                                            \
+    return (int)RunFunctionFmt(my_context, my_Length_fct_##A, "ppp", decoder, length, data); \
 }
 SUPER()
 #undef GO
@@ -226,11 +226,11 @@ static void* findLengthFct(void* fct)
     return NULL;
 }
 // Eof
-#define GO(A)                                                               \
-static uintptr_t my_Eof_fct_##A = 0;                                        \
-static int my_Eof_##A(void* decoder, void* data)                            \
-{                                                                           \
-    return (int)RunFunction(my_context, my_Eof_fct_##A, 2, decoder, data);  \
+#define GO(A)   \
+static uintptr_t my_Eof_fct_##A = 0;                                             \
+static int my_Eof_##A(void* decoder, void* data)                                 \
+{                                                                                \
+    return (int)RunFunctionFmt(my_context, my_Eof_fct_##A, "pp", decoder, data); \
 }
 SUPER()
 #undef GO
@@ -248,11 +248,11 @@ static void* findEofFct(void* fct)
     return NULL;
 }
 // Write
-#define GO(A)                                                                               \
-static uintptr_t my_Write_fct_##A = 0;                                                      \
-static int my_Write_##A(void* decoder, void* frame, void* buffer, void* data)               \
-{                                                                                           \
-    return (int)RunFunction(my_context, my_Write_fct_##A, 4, decoder, frame, buffer, data); \
+#define GO(A)   \
+static uintptr_t my_Write_fct_##A = 0;                                                              \
+static int my_Write_##A(void* decoder, void* frame, void* buffer, void* data)                       \
+{                                                                                                   \
+    return (int)RunFunctionFmt(my_context, my_Write_fct_##A, "pppp", decoder, frame, buffer, data); \
 }
 SUPER()
 #undef GO
@@ -270,11 +270,11 @@ static void* findWriteFct(void* fct)
     return NULL;
 }
 // Metadata
-#define GO(A)                                                                               \
-static uintptr_t my_Metadata_fct_##A = 0;                                                   \
-static int my_Metadata_##A(void* decoder, void* metadata, void* data)                       \
-{                                                                                           \
-    return (int)RunFunction(my_context, my_Metadata_fct_##A, 3, decoder, metadata, data);   \
+#define GO(A)   \
+static uintptr_t my_Metadata_fct_##A = 0;                                                        \
+static int my_Metadata_##A(void* decoder, void* metadata, void* data)                            \
+{                                                                                                \
+    return (int)RunFunctionFmt(my_context, my_Metadata_fct_##A, "ppp", decoder, metadata, data); \
 }
 SUPER()
 #undef GO
@@ -292,11 +292,11 @@ static void* findMetadataFct(void* fct)
     return NULL;
 }
 // Error
-#define GO(A)                                                               \
-static uintptr_t my_Error_fct_##A = 0;                                      \
-static void my_Error_##A(void* decoder, int status, void* data)             \
-{                                                                           \
-    RunFunction(my_context, my_Error_fct_##A, 3, decoder, status, data);    \
+#define GO(A)   \
+static uintptr_t my_Error_fct_##A = 0;                                          \
+static void my_Error_##A(void* decoder, int status, void* data)                 \
+{                                                                               \
+    RunFunctionFmt(my_context, my_Error_fct_##A, "pip", decoder, status, data); \
 }
 SUPER()
 #undef GO
@@ -317,7 +317,7 @@ static void* findErrorFct(void* fct)
 
 #undef SUPER
 
-EXPORT int my_FLAC__metadata_chain_read_with_callbacks(x64emu_t* emu, void* chain, void* handle, 
+EXPORT int my_FLAC__metadata_chain_read_with_callbacks(x64emu_t* emu, void* chain, void* handle,
     void* read_fnc, void* write_fnc, void* seek_fnc, void* tell_fnc, void* eof_fnc, void* close_fnc)
 {
     flac_callbacks cbs = {0};
@@ -332,10 +332,10 @@ EXPORT int my_FLAC__metadata_chain_read_with_callbacks(x64emu_t* emu, void* chai
 }
 
 EXPORT int my_FLAC__stream_decoder_init_stream(x64emu_t* emu, void* decoder,
-    void* read_fnc, void* seek_fnc, void* tell_fnc, void* length_fnc, void* eof_fnc, 
+    void* read_fnc, void* seek_fnc, void* tell_fnc, void* length_fnc, void* eof_fnc,
     void* write_fnc, void* metadata_fnc, void* error_fnc, void* data)
 {
-    int ret =  my->FLAC__stream_decoder_init_stream(decoder, 
+    int ret =  my->FLAC__stream_decoder_init_stream(decoder,
         findReadFct(read_fnc), findSeekFct(seek_fnc), findTellFct(tell_fnc),
         findLengthFct(length_fnc), findEofFct(eof_fnc), findWriteFct(write_fnc),
         findMetadataFct(metadata_fnc), findErrorFct(error_fnc), data);
diff --git a/src/wrapped/wrappedfreetype.c b/src/wrapped/wrappedfreetype.c
index aacad276..6088f033 100755
--- a/src/wrapped/wrappedfreetype.c
+++ b/src/wrapped/wrappedfreetype.c
@@ -133,10 +133,10 @@ GO(4)
 
 // FT_Generic_Finalizer
 #define GO(A)   \
-static uintptr_t my_FT_Generic_Finalizer_fct_##A = 0;                       \
-static void my_FT_Generic_Finalizer_##A(void* object)                       \
-{                                                                           \
-    RunFunction(my_context, my_FT_Generic_Finalizer_fct_##A, 1, object);    \
+static uintptr_t my_FT_Generic_Finalizer_fct_##A = 0;                         \
+static void my_FT_Generic_Finalizer_##A(void* object)                         \
+{                                                                             \
+    RunFunctionFmt(my_context, my_FT_Generic_Finalizer_fct_##A, "p", object); \
 }
 SUPER()
 #undef GO
@@ -156,15 +156,15 @@ static void* find_FT_Generic_Finalizer_Fct(void* fct)
 }
 // FTC_Face_Requester
 #define GO(A)   \
-static uintptr_t my_FTC_Face_Requester_fct_##A = 0;                                                     \
-static int my_FTC_Face_Requester_##A(void* face_id, void* lib, void* req, void* aface)                  \
-{                                                                                                       \
-    int ret = (int)RunFunction(my_context, my_FTC_Face_Requester_fct_##A, 4, face_id, lib, req, aface); \
-    if(aface && *(void**)aface) {                                                                       \
-        FT_FaceRec_t *f = *(FT_FaceRec_t**)aface;                                                       \
-        f->generic.finalizer = find_FT_Generic_Finalizer_Fct(f->generic.finalizer);                     \
-    }                                                                                                   \
-    return ret;                                                                                         \
+static uintptr_t my_FTC_Face_Requester_fct_##A = 0;                                                             \
+static int my_FTC_Face_Requester_##A(void* face_id, void* lib, void* req, void* aface)                          \
+{                                                                                                               \
+    int ret = (int)RunFunctionFmt(my_context, my_FTC_Face_Requester_fct_##A, "pppp", face_id, lib, req, aface); \
+    if(aface && *(void**)aface) {                                                                               \
+        FT_FaceRec_t *f = *(FT_FaceRec_t**)aface;                                                               \
+        f->generic.finalizer = find_FT_Generic_Finalizer_Fct(f->generic.finalizer);                             \
+    }                                                                                                           \
+    return ret;                                                                                                 \
 }
 SUPER()
 #undef GO
@@ -184,10 +184,10 @@ static void* find_FTC_Face_Requester_Fct(void* fct)
 }
 // FT_Alloc
 #define GO(A)   \
-static uintptr_t my_FT_Alloc_fct_##A = 0;                                       \
-static void* my_FT_Alloc_##A(void* memory, long size)                           \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_FT_Alloc_fct_##A, 2, memory, size);\
+static uintptr_t my_FT_Alloc_fct_##A = 0;                                              \
+static void* my_FT_Alloc_##A(void* memory, long size)                                  \
+{                                                                                      \
+    return (void*)RunFunctionFmt(my_context, my_FT_Alloc_fct_##A, "pl", memory, size); \
 }
 SUPER()
 #undef GO
@@ -207,10 +207,10 @@ static void* find_FT_Alloc_Fct(void* fct)
 }
 // FT_Free
 #define GO(A)   \
-static uintptr_t my_FT_Free_fct_##A = 0;                        \
-static void my_FT_Free_##A(void* memory, void* p)               \
-{                                                               \
-    RunFunction(my_context, my_FT_Free_fct_##A, 2, memory, p);  \
+static uintptr_t my_FT_Free_fct_##A = 0;                             \
+static void my_FT_Free_##A(void* memory, void* p)                    \
+{                                                                    \
+    RunFunctionFmt(my_context, my_FT_Free_fct_##A, "pp", memory, p); \
 }
 SUPER()
 #undef GO
@@ -230,10 +230,10 @@ static void* find_FT_Free_Fct(void* fct)
 }
 // FT_Realloc
 #define GO(A)   \
-static uintptr_t my_FT_Realloc_fct_##A = 0;                                                 \
-static void* my_FT_Realloc_##A(void* memory, long cur, long size, void* p)                  \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_FT_Realloc_fct_##A, 4, memory, cur, size, p);  \
+static uintptr_t my_FT_Realloc_fct_##A = 0;                                                        \
+static void* my_FT_Realloc_##A(void* memory, long cur, long size, void* p)                         \
+{                                                                                                  \
+    return (void*)RunFunctionFmt(my_context, my_FT_Realloc_fct_##A, "pllp", memory, cur, size, p); \
 }
 SUPER()
 #undef GO
@@ -253,10 +253,10 @@ static void* find_FT_Realloc_Fct(void* fct)
 }
 // FT_Outline_MoveToFunc
 #define GO(A)   \
-static uintptr_t my_FT_Outline_MoveToFunc_fct_##A = 0;                                  \
-static int my_FT_Outline_MoveToFunc_##A(void* to, void* user)                           \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_FT_Outline_MoveToFunc_fct_##A, 2, to, user); \
+static uintptr_t my_FT_Outline_MoveToFunc_fct_##A = 0;                                        \
+static int my_FT_Outline_MoveToFunc_##A(void* to, void* user)                                 \
+{                                                                                             \
+    return (int)RunFunctionFmt(my_context, my_FT_Outline_MoveToFunc_fct_##A, "pp", to, user); \
 }
 SUPER()
 #undef GO
@@ -277,10 +277,10 @@ static void* find_FT_Outline_MoveToFunc_Fct(void* fct)
 
 // FT_Outline_LineToFunc
 #define GO(A)   \
-static uintptr_t my_FT_Outline_LineToFunc_fct_##A = 0;                                  \
-static int my_FT_Outline_LineToFunc_##A(void* to, void* user)                           \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_FT_Outline_LineToFunc_fct_##A, 2, to, user); \
+static uintptr_t my_FT_Outline_LineToFunc_fct_##A = 0;                                        \
+static int my_FT_Outline_LineToFunc_##A(void* to, void* user)                                 \
+{                                                                                             \
+    return (int)RunFunctionFmt(my_context, my_FT_Outline_LineToFunc_fct_##A, "pp", to, user); \
 }
 SUPER()
 #undef GO
@@ -301,10 +301,10 @@ static void* find_FT_Outline_LineToFunc_Fct(void* fct)
 
 // FT_Outline_ConicToFunc
 #define GO(A)   \
-static uintptr_t my_FT_Outline_ConicToFunc_fct_##A = 0;                                         \
-static int my_FT_Outline_ConicToFunc_##A(void* ctl, void* to, void* user)                       \
-{                                                                                               \
-    return (int)RunFunction(my_context, my_FT_Outline_ConicToFunc_fct_##A, 3, ctl, to, user);   \
+static uintptr_t my_FT_Outline_ConicToFunc_fct_##A = 0;                                              \
+static int my_FT_Outline_ConicToFunc_##A(void* ctl, void* to, void* user)                            \
+{                                                                                                    \
+    return (int)RunFunctionFmt(my_context, my_FT_Outline_ConicToFunc_fct_##A, "ppp", ctl, to, user); \
 }
 SUPER()
 #undef GO
@@ -325,10 +325,10 @@ static void* find_FT_Outline_ConicToFunc_Fct(void* fct)
 
 // FT_Outline_CubicToFunc
 #define GO(A)   \
-static uintptr_t my_FT_Outline_CubicToFunc_fct_##A = 0;                                                 \
-static int my_FT_Outline_CubicToFunc_##A(void* ctl1, void* ctl2, void* to, void* user)                  \
-{                                                                                                       \
-    return (int)RunFunction(my_context, my_FT_Outline_CubicToFunc_fct_##A, 4, ctl1, ctl2, to, user);    \
+static uintptr_t my_FT_Outline_CubicToFunc_fct_##A = 0;                                                      \
+static int my_FT_Outline_CubicToFunc_##A(void* ctl1, void* ctl2, void* to, void* user)                       \
+{                                                                                                            \
+    return (int)RunFunctionFmt(my_context, my_FT_Outline_CubicToFunc_fct_##A, "pppp", ctl1, ctl2, to, user); \
 }
 SUPER()
 #undef GO
@@ -378,13 +378,13 @@ static FT_MemoryRec_t* find_FT_MemoryRec_Struct(FT_MemoryRec_t* s)
 static uintptr_t my_iofunc = 0;
 static unsigned long my_FT_Stream_IoFunc(FT_StreamRec_t* stream, unsigned long offset, unsigned char* buffer, unsigned long count )
 {
-    return (unsigned long)RunFunction(my_context, my_iofunc, 4, stream, offset, buffer, count);
+    return (unsigned long)RunFunctionFmt(my_context, my_iofunc, "pLpL", stream, offset, buffer, count);
 }
 
 static uintptr_t my_closefunc = 0;
 static void my_FT_Stream_CloseFunc(FT_StreamRec_t* stream)
 {
-    RunFunction(my_context, my_closefunc, 1, stream);
+    RunFunctionFmt(my_context, my_closefunc, "p", stream);
 }
 
 EXPORT int my_FT_Open_Face(x64emu_t* emu, void* library, FT_Open_Args_t* args, long face_index, void* aface)
diff --git a/src/wrapped/wrappedgconf2.c b/src/wrapped/wrappedgconf2.c
index 6e656f71..200f4750 100644
--- a/src/wrapped/wrappedgconf2.c
+++ b/src/wrapped/wrappedgconf2.c
@@ -34,10 +34,10 @@ GO(3)
 
 // GFreeFct
 #define GO(A)   \
-static uintptr_t my_GFreeFct_fct_##A = 0;               \
-static void my_GFreeFct_##A(void* a)                    \
-{                                                       \
-    RunFunction(my_context, my_GFreeFct_fct_##A, 1, a); \
+static uintptr_t my_GFreeFct_fct_##A = 0;                    \
+static void my_GFreeFct_##A(void* a)                         \
+{                                                            \
+    RunFunctionFmt(my_context, my_GFreeFct_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -56,10 +56,10 @@ static void* findGFreeFctFct(void* fct)
 }
 // GConfClientNotifyFunc
 #define GO(A)   \
-static uintptr_t my_GConfClientNotifyFunc_fct_##A = 0;                          \
-static void my_GConfClientNotifyFunc_##A(void* a, uint32_t b, void* c, void* d) \
-{                                                                               \
-    RunFunction(my_context, my_GConfClientNotifyFunc_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_GConfClientNotifyFunc_fct_##A = 0;                                \
+static void my_GConfClientNotifyFunc_##A(void* a, uint32_t b, void* c, void* d)       \
+{                                                                                     \
+    RunFunctionFmt(my_context, my_GConfClientNotifyFunc_fct_##A, "pupp", a, b, c, d); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedgdk3.c b/src/wrapped/wrappedgdk3.c
index 671301b9..d695f451 100755
--- a/src/wrapped/wrappedgdk3.c
+++ b/src/wrapped/wrappedgdk3.c
@@ -37,10 +37,10 @@ GO(3)
 
 // GdkFilterFunc
 #define GO(A)   \
-static uintptr_t my_filter_fct_##A = 0;   \
-static int my_filter_##A(void* xevent, void* event, void* data)     \
-{                                       \
-    return (int)RunFunction(my_context, my_filter_fct_##A, 3, xevent, event, data);\
+static uintptr_t my_filter_fct_##A = 0;                                                    \
+static int my_filter_##A(void* xevent, void* event, void* data)                            \
+{                                                                                          \
+    return (int)RunFunctionFmt(my_context, my_filter_fct_##A, "ppp", xevent, event, data); \
 }
 SUPER()
 #undef GO
@@ -61,7 +61,7 @@ static void* findFilterFct(void* fct)
 
 static void my3_event_handler(void* event, my_signal_t* sig)
 {
-    RunFunction(my_context, sig->c_handler, 2, event, sig->data);
+    RunFunctionFmt(my_context, sig->c_handler, "pp", event, sig->data);
 }
 
 EXPORT void my3_gdk_event_handler_set(x64emu_t* emu, void* func, void* data, void* notify)
@@ -76,7 +76,7 @@ EXPORT void my3_gdk_event_handler_set(x64emu_t* emu, void* func, void* data, voi
 
 static void my3_input_function(my_signal_t* sig, int source, int condition)
 {
-    RunFunction(my_context, sig->c_handler, 3, sig->data, source, condition);
+    RunFunctionFmt(my_context, sig->c_handler, "pii", sig->data, source, condition);
 }
 
 EXPORT int my3_gdk_input_add(x64emu_t* emu, int source, int condition, void* f, void* data)
@@ -92,7 +92,7 @@ EXPORT int my3_gdk_input_add_full(x64emu_t* emu, int source, int condition, void
 {
     if(!f)
         return my->gdk_input_add_full(source, condition, f, data, notify);
-    
+
     my_signal_t* sig = new_mysignal(f, data, notify);
     return my->gdk_input_add_full(source, condition, my3_input_function, sig, my_signal_delete);
 }
diff --git a/src/wrapped/wrappedgdkpixbuf2.c b/src/wrapped/wrappedgdkpixbuf2.c
index 1f82399d..09adebe7 100755
--- a/src/wrapped/wrappedgdkpixbuf2.c
+++ b/src/wrapped/wrappedgdkpixbuf2.c
@@ -32,10 +32,10 @@ GO(3)
 
 // destroy_pixbuf
 #define GO(A)   \
-static uintptr_t my_destroy_pixbuf_fct_##A = 0;                             \
-static void my_destroy_pixbuf_##A(void* pixels, void* data)                 \
-{                                                                           \
-    RunFunction(my_context, my_destroy_pixbuf_fct_##A, 2, pixels, data);    \
+static uintptr_t my_destroy_pixbuf_fct_##A = 0;                                \
+static void my_destroy_pixbuf_##A(void* pixels, void* data)                    \
+{                                                                              \
+    RunFunctionFmt(my_context, my_destroy_pixbuf_fct_##A, "pp", pixels, data); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedgdkx112.c b/src/wrapped/wrappedgdkx112.c
index 4f3aeba4..15a0ba41 100755
--- a/src/wrapped/wrappedgdkx112.c
+++ b/src/wrapped/wrappedgdkx112.c
@@ -37,10 +37,10 @@ GO(3)
 
 // GdkFilterFunc
 #define GO(A)   \
-static uintptr_t my_filter_fct_##A = 0;   \
-static int my_filter_##A(void* xevent, void* event, void* data)     \
-{                                       \
-    return (int)RunFunction(my_context, my_filter_fct_##A, 3, xevent, event, data);\
+static uintptr_t my_filter_fct_##A = 0;                                                    \
+static int my_filter_##A(void* xevent, void* event, void* data)                            \
+{                                                                                          \
+    return (int)RunFunctionFmt(my_context, my_filter_fct_##A, "ppp", xevent, event, data); \
 }
 SUPER()
 #undef GO
@@ -61,7 +61,7 @@ static void* findFilterFct(void* fct)
 
 static void my_event_handler(void* event, my_signal_t* sig)
 {
-    RunFunction(my_context, sig->c_handler, 2, event, sig->data);
+    RunFunctionFmt(my_context, sig->c_handler, "pp", event, sig->data);
 }
 
 EXPORT void my_gdk_event_handler_set(x64emu_t* emu, void* func, void* data, void* notify)
@@ -76,7 +76,7 @@ EXPORT void my_gdk_event_handler_set(x64emu_t* emu, void* func, void* data, void
 
 static void my_input_function(my_signal_t* sig, int source, int condition)
 {
-    RunFunction(my_context, sig->c_handler, 3, sig->data, source, condition);
+    RunFunctionFmt(my_context, sig->c_handler, "pii", sig->data, source, condition);
 }
 
 EXPORT int my_gdk_input_add(x64emu_t* emu, int source, int condition, void* f, void* data)
@@ -92,7 +92,7 @@ EXPORT int my_gdk_input_add_full(x64emu_t* emu, int source, int condition, void*
 {
     if(!f)
         return my->gdk_input_add_full(source, condition, f, data, notify);
-    
+
     my_signal_t* sig = new_mysignal(f, data, notify);
     return my->gdk_input_add_full(source, condition, my_input_function, sig, my_signal_delete);
 }
diff --git a/src/wrapped/wrappedgio2.c b/src/wrapped/wrappedgio2.c
index ef379ef1..ec9e6fc6 100755
--- a/src/wrapped/wrappedgio2.c
+++ b/src/wrapped/wrappedgio2.c
@@ -27,7 +27,7 @@ typedef size_t(*LFv_t)(void);
 
 #define ADDED_FUNCTIONS() \
  GO(g_application_get_type, LFv_t)           \
- 
+
 #include "wrappedgio2types.h"
 
 #include "wrappercallback.h"
@@ -40,10 +40,10 @@ GO(3)
 
 // GAsyncReadyCallback
 #define GO(A)   \
-static uintptr_t my_GAsyncReadyCallback_fct_##A = 0;   \
-static void my_GAsyncReadyCallback_##A(void* source, void* res, void* data)     \
-{                                       \
-    RunFunction(my_context, my_GAsyncReadyCallback_fct_##A, 3, source, res, data);\
+static uintptr_t my_GAsyncReadyCallback_fct_##A = 0;                                      \
+static void my_GAsyncReadyCallback_##A(void* source, void* res, void* data)               \
+{                                                                                         \
+    RunFunctionFmt(my_context, my_GAsyncReadyCallback_fct_##A, "ppp", source, res, data); \
 }
 SUPER()
 #undef GO
@@ -63,10 +63,10 @@ static void* findGAsyncReadyCallbackFct(void* fct)
 
 // GDestroyNotify
 #define GO(A)   \
-static uintptr_t my_GDestroyNotify_fct_##A = 0;   \
-static void my_GDestroyNotify_##A(void* data)     \
-{                                       \
-    RunFunction(my_context, my_GDestroyNotify_fct_##A, 1, data);\
+static uintptr_t my_GDestroyNotify_fct_##A = 0;                       \
+static void my_GDestroyNotify_##A(void* data)                         \
+{                                                                     \
+    RunFunctionFmt(my_context, my_GDestroyNotify_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -86,10 +86,10 @@ static void* findGDestroyNotifyFct(void* fct)
 
 // GDBusProxyTypeFunc
 #define GO(A)   \
-static uintptr_t my_GDBusProxyTypeFunc_fct_##A = 0;   \
-static int my_GDBusProxyTypeFunc_##A(void* manager, void* path, void* name, void* data)     \
-{                                       \
-    return (int)RunFunction(my_context, my_GDBusProxyTypeFunc_fct_##A, 4, manager, path, name, data);\
+static uintptr_t my_GDBusProxyTypeFunc_fct_##A = 0;                                                           \
+static int my_GDBusProxyTypeFunc_##A(void* manager, void* path, void* name, void* data)                       \
+{                                                                                                             \
+    return (int)RunFunctionFmt(my_context, my_GDBusProxyTypeFunc_fct_##A, "pppp", manager, path, name, data); \
 }
 SUPER()
 #undef GO
@@ -109,10 +109,10 @@ static void* findGDBusProxyTypeFuncFct(void* fct)
 
 // GSimpleAsyncThreadFunc
 #define GO(A)   \
-static uintptr_t my_GSimpleAsyncThreadFunc_fct_##A = 0;   \
-static void my_GSimpleAsyncThreadFunc_##A(void* res, void* object, void* cancellable)     \
-{                                       \
-    RunFunction(my_context, my_GSimpleAsyncThreadFunc_fct_##A, 3, res, object, cancellable);\
+static uintptr_t my_GSimpleAsyncThreadFunc_fct_##A = 0;                                             \
+static void my_GSimpleAsyncThreadFunc_##A(void* res, void* object, void* cancellable)               \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_GSimpleAsyncThreadFunc_fct_##A, "ppp", res, object, cancellable); \
 }
 SUPER()
 #undef GO
@@ -132,10 +132,10 @@ static void* findGSimpleAsyncThreadFuncFct(void* fct)
 
 // GCallback
 #define GO(A)   \
-static uintptr_t my_GCallback_fct_##A = 0;   \
-static void my_GCallback_##A(void* a, void* b, void* c, void* d)     \
-{                                       \
-    RunFunction(my_context, my_GCallback_fct_##A, 4, a, b, c, d);\
+static uintptr_t my_GCallback_fct_##A = 0;                                \
+static void my_GCallback_##A(void* a, void* b, void* c, void* d)          \
+{                                                                         \
+    RunFunctionFmt(my_context, my_GCallback_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -155,10 +155,10 @@ static void* findGCallbackFct(void* fct)
 
 // GDBusSignalCallback
 #define GO(A)   \
-static uintptr_t my_GDBusSignalCallback_fct_##A = 0;   \
-static void my_GDBusSignalCallback_##A(void* connection, void* sender, void* object, void* interface, void* signal, void* param, void* data)     \
-{                                       \
-    RunFunction(my_context, my_GDBusSignalCallback_fct_##A, 7, connection, sender, object, interface, signal, param, data);\
+static uintptr_t my_GDBusSignalCallback_fct_##A = 0;                                                                                         \
+static void my_GDBusSignalCallback_##A(void* connection, void* sender, void* object, void* interface, void* signal, void* param, void* data) \
+{                                                                                                                                            \
+    RunFunctionFmt(my_context, my_GDBusSignalCallback_fct_##A, "ppppppp", connection, sender, object, interface, signal, param, data);       \
 }
 SUPER()
 #undef GO
@@ -178,10 +178,10 @@ static void* findGDBusSignalCallbackFct(void* fct)
 
 // GDBusMessageFilterFunction
 #define GO(A)   \
-static uintptr_t my_GDBusMessageFilterFunction_fct_##A = 0;   \
-static void my_GDBusMessageFilterFunction_##A(void* connection, void* message, int incoming, void* data)     \
-{                                       \
-    RunFunction(my_context, my_GDBusMessageFilterFunction_fct_##A, 4, connection, message, incoming, data);\
+static uintptr_t my_GDBusMessageFilterFunction_fct_##A = 0;                                                         \
+static void my_GDBusMessageFilterFunction_##A(void* connection, void* message, int incoming, void* data)            \
+{                                                                                                                   \
+    RunFunctionFmt(my_context, my_GDBusMessageFilterFunction_fct_##A, "ppip", connection, message, incoming, data); \
 }
 SUPER()
 #undef GO
@@ -201,10 +201,10 @@ static void* findGDBusMessageFilterFunctionFct(void* fct)
 
 // GBusNameAppearedCallback
 #define GO(A)   \
-static uintptr_t my_GBusNameAppearedCallback_fct_##A = 0;   \
-static void my_GBusNameAppearedCallback_##A(void* connection, void* name, void* owner, void* data)  \
-{                                       \
-    RunFunction(my_context, my_GBusNameAppearedCallback_fct_##A, 4, connection, name, owner, data); \
+static uintptr_t my_GBusNameAppearedCallback_fct_##A = 0;                                                   \
+static void my_GBusNameAppearedCallback_##A(void* connection, void* name, void* owner, void* data)          \
+{                                                                                                           \
+    RunFunctionFmt(my_context, my_GBusNameAppearedCallback_fct_##A, "pppp", connection, name, owner, data); \
 }
 SUPER()
 #undef GO
@@ -224,10 +224,10 @@ static void* findGBusNameAppearedCallbackFct(void* fct)
 
 // GBusNameVanishedCallback
 #define GO(A)   \
-static uintptr_t my_GBusNameVanishedCallback_fct_##A = 0;   \
-static void my_GBusNameVanishedCallback_##A(void* connection, void* name, void* data)       \
-{                                       \
-    RunFunction(my_context, my_GBusNameVanishedCallback_fct_##A, 3, connection, name, data);\
+static uintptr_t my_GBusNameVanishedCallback_fct_##A = 0;                                           \
+static void my_GBusNameVanishedCallback_##A(void* connection, void* name, void* data)               \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_GBusNameVanishedCallback_fct_##A, "ppp", connection, name, data); \
 }
 SUPER()
 #undef GO
@@ -247,10 +247,10 @@ static void* findGBusNameVanishedCallbackFct(void* fct)
 
 // GBusAcquiredCallback
 #define GO(A)   \
-static uintptr_t my_GBusAcquiredCallback_fct_##A = 0;   \
-static void my_GBusAcquiredCallback_##A(void* connection, void* name, void* data)       \
-{                                       \
-    RunFunction(my_context, my_GBusAcquiredCallback_fct_##A, 3, connection, name, data);\
+static uintptr_t my_GBusAcquiredCallback_fct_##A = 0;                                           \
+static void my_GBusAcquiredCallback_##A(void* connection, void* name, void* data)               \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_GBusAcquiredCallback_fct_##A, "ppp", connection, name, data); \
 }
 SUPER()
 #undef GO
@@ -270,10 +270,10 @@ static void* findGBusAcquiredCallbackFct(void* fct)
 
 // GBusNameAcquiredCallback
 #define GO(A)   \
-static uintptr_t my_GBusNameAcquiredCallback_fct_##A = 0;   \
-static void my_GBusNameAcquiredCallback_##A(void* connection, void* name, void* data)       \
-{                                       \
-    RunFunction(my_context, my_GBusNameAcquiredCallback_fct_##A, 3, connection, name, data);\
+static uintptr_t my_GBusNameAcquiredCallback_fct_##A = 0;                                           \
+static void my_GBusNameAcquiredCallback_##A(void* connection, void* name, void* data)               \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_GBusNameAcquiredCallback_fct_##A, "ppp", connection, name, data); \
 }
 SUPER()
 #undef GO
@@ -293,10 +293,10 @@ static void* findGBusNameAcquiredCallbackFct(void* fct)
 
 // GBusNameLostCallback
 #define GO(A)   \
-static uintptr_t my_GBusNameLostCallback_fct_##A = 0;   \
-static void my_GBusNameLostCallback_##A(void* connection, void* name, void* data)       \
-{                                       \
-    RunFunction(my_context, my_GBusNameLostCallback_fct_##A, 3, connection, name, data);\
+static uintptr_t my_GBusNameLostCallback_fct_##A = 0;                                           \
+static void my_GBusNameLostCallback_##A(void* connection, void* name, void* data)               \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_GBusNameLostCallback_fct_##A, "ppp", connection, name, data); \
 }
 SUPER()
 #undef GO
@@ -322,24 +322,24 @@ typedef struct my_GDBusInterfaceVTable_s {
   int       (*set_property)   (void* connection, void* sender, void* object_path, void* interface_name, void* value, void* error, void* user_data);
 } my_GDBusInterfaceVTable_t;
 
-#define GO(A) \
+#define GO(A)   \
 static my_GDBusInterfaceVTable_t     my_GDBusInterfaceVTable_##A = {0};   \
 static my_GDBusInterfaceVTable_t   *ref_GDBusInterfaceVTable_##A = NULL;
 SUPER()
 #undef GO
 // then the static functions callback that may be used with the structure, but dispatch also have a callback...
 #define GO(A)   \
-static uintptr_t fct_funcs_method_call_##A = 0;                   \
-static void my_funcs_method_call_##A(void* connection, void* sender, void* object_path, void* interface_name, void* method_name, void* invocation, void* user_data) {               \
-    RunFunction(my_context, fct_funcs_method_call_##A, 8, connection, sender, object_path, interface_name, method_name, invocation, user_data);                \
-}   \
-static uintptr_t fct_funcs_get_property_##A = 0;                        \
-static void* my_funcs_get_property_##A(void* connection, void* sender, void* object_path, void* interface_name, void* error, void* user_data) {                     \
-    return (void*)RunFunction(my_context, fct_funcs_get_property_##A, 7, connection, sender, object_path, interface_name, error, user_data);                        \
-}   \
-static uintptr_t fct_funcs_set_property_##A = 0;                        \
-static int my_funcs_set_property_##A(void* connection, void* sender, void* object_path, void* interface_name, void* value, void* error, void* user_data) {          \
-    return (int)RunFunction(my_context, fct_funcs_set_property_##A, 8, connection, sender, object_path, interface_name, value, error, user_data);                   \
+static uintptr_t fct_funcs_method_call_##A = 0; \
+static void my_funcs_method_call_##A(void* connection, void* sender, void* object_path, void* interface_name, void* method_name, void* invocation, void* user_data) { \
+    RunFunctionFmt(my_context, fct_funcs_method_call_##A, "ppppppp", connection, sender, object_path, interface_name, method_name, invocation, user_data); \
+} \
+static uintptr_t fct_funcs_get_property_##A = 0; \
+static void* my_funcs_get_property_##A(void* connection, void* sender, void* object_path, void* interface_name, void* error, void* user_data) { \
+    return (void*)RunFunctionFmt(my_context, fct_funcs_get_property_##A, "pppppp", connection, sender, object_path, interface_name, error, user_data); \
+} \
+static uintptr_t fct_funcs_set_property_##A = 0; \
+static int my_funcs_set_property_##A(void* connection, void* sender, void* object_path, void* interface_name, void* value, void* error, void* user_data) { \
+    return (int)RunFunctionFmt(my_context, fct_funcs_set_property_##A, "ppppppp", connection, sender, object_path, interface_name, value, error, user_data); \
 }
 
 SUPER()
diff --git a/src/wrapped/wrappedglib2.c b/src/wrapped/wrappedglib2.c
index 30bfbdd6..0c5c3101 100755
--- a/src/wrapped/wrappedglib2.c
+++ b/src/wrapped/wrappedglib2.c
@@ -57,7 +57,7 @@ EXPORT void* my_g_build_filename(x64emu_t* emu, void* first, uintptr_t* b)
 
 static int my_timeout_cb(my_signal_t* sig)
 {
-    return (int)RunFunction(my_context, sig->c_handler, 1, sig->data);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "p", sig->data);
 }
 EXPORT uint32_t my_g_timeout_add(x64emu_t* emu, uint32_t interval, void* func, void* data)
 {
@@ -89,10 +89,10 @@ GO(9)   \
 
 // GCopyFct
 #define GO(A)   \
-static uintptr_t my_copy_fct_##A = 0;   \
-static void* my_copy_##A(void* data)     \
-{                                       \
-    return (void*)RunFunction(my_context, my_copy_fct_##A, 1, data);\
+static uintptr_t my_copy_fct_##A = 0;                                     \
+static void* my_copy_##A(void* data)                                      \
+{                                                                         \
+    return (void*)RunFunctionFmt(my_context, my_copy_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -111,10 +111,10 @@ static void* findCopyFct(void* fct)
 }
 // GFreeFct
 #define GO(A)   \
-static uintptr_t my_free_fct_##A = 0;   \
-static void my_free_##A(void* data)     \
-{                                       \
-    RunFunction(my_context, my_free_fct_##A, 1, data);\
+static uintptr_t my_free_fct_##A = 0;                       \
+static void my_free_##A(void* data)                         \
+{                                                           \
+    RunFunctionFmt(my_context, my_free_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -133,10 +133,10 @@ static void* findFreeFct(void* fct)
 }
 // GDuplicateFct
 #define GO(A)   \
-static uintptr_t my_duplicate_fct_##A = 0;   \
-static void* my_duplicate_##A(void* data)     \
-{                                       \
-    return (void*)RunFunction(my_context, my_duplicate_fct_##A, 1, data);\
+static uintptr_t my_duplicate_fct_##A = 0;                                     \
+static void* my_duplicate_##A(void* data)                                      \
+{                                                                              \
+    return (void*)RunFunctionFmt(my_context, my_duplicate_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -155,35 +155,35 @@ static void* findDuplicateFct(void* fct)
 }
 // GSourceFuncs....
 // g_source_new callback. First the structure GSourceFuncs statics, with paired x64 source pointer
-#define GO(A) \
+#define GO(A)   \
 static my_GSourceFuncs_t     my_gsourcefuncs_##A = {0};   \
 static my_GSourceFuncs_t   *ref_gsourcefuncs_##A = NULL;
 SUPER()
 #undef GO
 // then the static functions callback that may be used with the structure, but dispatch also have a callback...
 #define GO(A)   \
-static uintptr_t fct_funcs_prepare_##A = 0;                                             \
-static int my_funcs_prepare_##A(void* source, int *timeout_) {                          \
-    return (int)RunFunction(my_context, fct_funcs_prepare_##A, 2, source, timeout_);    \
-}   \
-static uintptr_t fct_funcs_check_##A = 0;                                   \
-static int my_funcs_check_##A(void* source) {                               \
-    return (int)RunFunction(my_context, fct_funcs_check_##A, 1, source);    \
-}   \
-static uintptr_t fct_funcs_dispatch_cb_##A = 0;                                         \
-static int my_funcs_dispatch_cb_##A(void* a, void* b, void* c, void* d) {               \
-    return (int)RunFunction(my_context, fct_funcs_dispatch_cb_##A, 4, a, b, c, d);      \
-}   \
-static uintptr_t fct_funcs_dispatch_##A = 0;  \
-static int my_funcs_dispatch_##A(void* source, void* cb, void* data) {   \
-    uintptr_t old = fct_funcs_dispatch_cb_##A;  \
-    fct_funcs_dispatch_cb_##A = (uintptr_t)cb;  \
-    return (int)RunFunction(my_context, fct_funcs_dispatch_##A, 3, source, cb?my_funcs_dispatch_cb_##A:NULL, data);    \
-    fct_funcs_dispatch_cb_##A = old;    \
-}   \
-static uintptr_t fct_funcs_finalize_##A = 0;  \
-static int my_funcs_finalize_##A(void* source) {   \
-    return (int)RunFunction(my_context, fct_funcs_finalize_##A, 1, source);    \
+static uintptr_t fct_funcs_prepare_##A = 0;                                                \
+static int my_funcs_prepare_##A(void* source, int *timeout_) {                             \
+    return (int)RunFunctionFmt(my_context, fct_funcs_prepare_##A, "pp", source, timeout_); \
+}                                                                                          \
+static uintptr_t fct_funcs_check_##A = 0;                                     \
+static int my_funcs_check_##A(void* source) {                                 \
+    return (int)RunFunctionFmt(my_context, fct_funcs_check_##A, "p", source); \
+}                                                                             \
+static uintptr_t fct_funcs_dispatch_cb_##A = 0;                                            \
+static int my_funcs_dispatch_cb_##A(void* a, void* b, void* c, void* d) {                  \
+    return (int)RunFunctionFmt(my_context, fct_funcs_dispatch_cb_##A, "pppp", a, b, c, d); \
+}                                                                                          \
+static uintptr_t fct_funcs_dispatch_##A = 0;                           \
+static int my_funcs_dispatch_##A(void* source, void* cb, void* data) { \
+    uintptr_t old = fct_funcs_dispatch_cb_##A;                         \
+    fct_funcs_dispatch_cb_##A = (uintptr_t)cb;                         \
+    return (int)RunFunctionFmt(my_context, fct_funcs_dispatch_##A, "ppp", source, cb?my_funcs_dispatch_cb_##A:NULL, data); \
+    fct_funcs_dispatch_cb_##A = old;                                   \
+}                                                                      \
+static uintptr_t fct_funcs_finalize_##A = 0;                           \
+static int my_funcs_finalize_##A(void* source) {                       \
+    return (int)RunFunctionFmt(my_context, fct_funcs_finalize_##A, "p", source); \
 }
 SUPER()
 #undef GO
@@ -214,10 +214,10 @@ static my_GSourceFuncs_t* findFreeGSourceFuncs(my_GSourceFuncs_t* fcts)
 
 // PollFunc ...
 #define GO(A)   \
-static uintptr_t my_poll_fct_##A = 0;   \
-static int my_poll_##A(void* ufds, uint32_t nfsd, int32_t timeout_)     \
-{                                       \
-    return RunFunction(my_context, my_poll_fct_##A, 3, ufds, nfsd, timeout_);\
+static uintptr_t my_poll_fct_##A = 0;                                                \
+static int my_poll_##A(void* ufds, uint32_t nfsd, int32_t timeout_)                  \
+{                                                                                    \
+    return RunFunctionFmt(my_context, my_poll_fct_##A, "pui", ufds, nfsd, timeout_); \
 }
 SUPER()
 #undef GO
@@ -246,10 +246,10 @@ static void* reversePollFct(void* fct)
 
 // GHashFunc ...
 #define GO(A)   \
-static uintptr_t my_hashfunc_fct_##A = 0;   \
-static uint32_t my_hashfunc_##A(void* key)     \
-{                                       \
-    return (uint32_t)RunFunction(my_context, my_hashfunc_fct_##A, 1, key);\
+static uintptr_t my_hashfunc_fct_##A = 0;                                       \
+static uint32_t my_hashfunc_##A(void* key)                                      \
+{                                                                               \
+    return (uint32_t)RunFunctionFmt(my_context, my_hashfunc_fct_##A, "p", key); \
 }
 SUPER()
 #undef GO
@@ -268,10 +268,10 @@ static void* findHashFct(void* fct)
 }
 // GEqualFunc ...
 #define GO(A)   \
-static uintptr_t my_equalfunc_fct_##A = 0;   \
-static int my_equalfunc_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_equalfunc_fct_##A, 2, a, b);\
+static uintptr_t my_equalfunc_fct_##A = 0;                               \
+static int my_equalfunc_##A(void* a, void* b)                            \
+{                                                                        \
+    return RunFunctionFmt(my_context, my_equalfunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -290,10 +290,10 @@ static void* findEqualFct(void* fct)
 }
 // GDestroyFunc ...
 #define GO(A)   \
-static uintptr_t my_destroyfunc_fct_##A = 0;   \
-static int my_destroyfunc_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_destroyfunc_fct_##A, 2, a, b);\
+static uintptr_t my_destroyfunc_fct_##A = 0;                               \
+static int my_destroyfunc_##A(void* a, void* b)                            \
+{                                                                          \
+    return RunFunctionFmt(my_context, my_destroyfunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -312,10 +312,10 @@ static void* findDestroyFct(void* fct)
 }
 // GSpawnChildSetupFunc ...
 #define GO(A)   \
-static uintptr_t my_spwnchildsetup_fct_##A = 0;   \
-static void my_spwnchildsetup_##A(void* data)     \
-{                                       \
-    RunFunction(my_context, my_spwnchildsetup_fct_##A, 1, data);\
+static uintptr_t my_spwnchildsetup_fct_##A = 0;                       \
+static void my_spwnchildsetup_##A(void* data)                         \
+{                                                                     \
+    RunFunctionFmt(my_context, my_spwnchildsetup_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -334,10 +334,10 @@ static void* findSpawnChildSetupFct(void* fct)
 }
 // GSourceFunc ...
 #define GO(A)   \
-static uintptr_t my_GSourceFunc_fct_##A = 0;   \
-static void my_GSourceFunc_##A(void* a, void* b, void* c, void* d)     \
-{                                       \
-    RunFunction(my_context, my_GSourceFunc_fct_##A, 4, a, b, c, d);\
+static uintptr_t my_GSourceFunc_fct_##A = 0;                                \
+static void my_GSourceFunc_##A(void* a, void* b, void* c, void* d)          \
+{                                                                           \
+    RunFunctionFmt(my_context, my_GSourceFunc_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -356,10 +356,10 @@ static void* findGSourceFuncFct(void* fct)
 }
 // GCompareFunc ...
 #define GO(A)   \
-static uintptr_t my_GCompareFunc_fct_##A = 0;   \
-static int my_GCompareFunc_##A(void* a, void* b)     \
-{                                       \
-    return (int)RunFunction(my_context, my_GCompareFunc_fct_##A, 2, a, b);\
+static uintptr_t my_GCompareFunc_fct_##A = 0;                                    \
+static int my_GCompareFunc_##A(void* a, void* b)                                 \
+{                                                                                \
+    return (int)RunFunctionFmt(my_context, my_GCompareFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -378,10 +378,10 @@ static void* findGCompareFuncFct(void* fct)
 }
 // GCompareDataFunc ...
 #define GO(A)   \
-static uintptr_t my_GCompareDataFunc_fct_##A = 0;                   \
-static int my_GCompareDataFunc_##A(void* a, void* b, void* data)    \
-{                                       \
-    return (int)RunFunction(my_context, my_GCompareDataFunc_fct_##A, 3, a, b, data);\
+static uintptr_t my_GCompareDataFunc_fct_##A = 0;                                           \
+static int my_GCompareDataFunc_##A(void* a, void* b, void* data)                            \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GCompareDataFunc_fct_##A, "ppp", a, b, data); \
 }
 SUPER()
 #undef GO
@@ -400,10 +400,10 @@ static void* findGCompareDataFuncFct(void* fct)
 }
 // GCompletionFunc ...
 #define GO(A)   \
-static uintptr_t my_GCompletionFunc_fct_##A = 0;                            \
-static void* my_GCompletionFunc_##A(void* a)                                \
-{                                                                           \
-    return (void*)RunFunction(my_context, my_GCompletionFunc_fct_##A, 1, a);\
+static uintptr_t my_GCompletionFunc_fct_##A = 0;                                  \
+static void* my_GCompletionFunc_##A(void* a)                                      \
+{                                                                                 \
+    return (void*)RunFunctionFmt(my_context, my_GCompletionFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -422,10 +422,10 @@ static void* findGCompletionFct(void* fct)
 }
 // GCompletionStrncmpFunc ...
 #define GO(A)   \
-static uintptr_t my_GCompletionStrncmpFunc_fct_##A = 0;                                 \
-static int my_GCompletionStrncmpFunc_##A(void* a, void* b, unsigned long n)             \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GCompletionStrncmpFunc_fct_##A, 3, a, b, n); \
+static uintptr_t my_GCompletionStrncmpFunc_fct_##A = 0;                                        \
+static int my_GCompletionStrncmpFunc_##A(void* a, void* b, unsigned long n)                    \
+{                                                                                              \
+    return (int)RunFunctionFmt(my_context, my_GCompletionStrncmpFunc_fct_##A, "ppL", a, b, n); \
 }
 SUPER()
 #undef GO
@@ -444,10 +444,10 @@ static void* findGCompletionStrncmpFuncFct(void* fct)
 }
 // GIOFunc ...
 #define GO(A)   \
-static uintptr_t my_GIOFunc_fct_##A = 0;                                 \
-static int my_GIOFunc_##A(void* a, int b, void* c)             \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GIOFunc_fct_##A, 3, a, b, c); \
+static uintptr_t my_GIOFunc_fct_##A = 0;                                        \
+static int my_GIOFunc_##A(void* a, int b, void* c)                              \
+{                                                                               \
+    return (int)RunFunctionFmt(my_context, my_GIOFunc_fct_##A, "pip", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -466,10 +466,10 @@ static void* findGIOFuncFct(void* fct)
 }
 // GDestroyNotify ...
 #define GO(A)   \
-static uintptr_t my_GDestroyNotify_fct_##A = 0;                 \
-static void my_GDestroyNotify_##A(void* a)                      \
-{                                                               \
-    RunFunction(my_context, my_GDestroyNotify_fct_##A, 1, a);   \
+static uintptr_t my_GDestroyNotify_fct_##A = 0;                    \
+static void my_GDestroyNotify_##A(void* a)                         \
+{                                                                  \
+    RunFunctionFmt(my_context, my_GDestroyNotify_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -488,10 +488,10 @@ static void* findGDestroyNotifyFct(void* fct)
 }
 // GFunc ...
 #define GO(A)   \
-static uintptr_t my_GFunc_fct_##A = 0;                  \
-static void my_GFunc_##A(void* a, void* b)              \
-{                                                       \
-    RunFunction(my_context, my_GFunc_fct_##A, 2, a, b); \
+static uintptr_t my_GFunc_fct_##A = 0;                        \
+static void my_GFunc_##A(void* a, void* b)                    \
+{                                                             \
+    RunFunctionFmt(my_context, my_GFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -510,10 +510,10 @@ static void* findGFuncFct(void* fct)
 }
 // GHFunc ...
 #define GO(A)   \
-static uintptr_t my_GHFunc_fct_##A = 0;                     \
-static void my_GHFunc_##A(void* a, void* b, void* c)        \
-{                                                           \
-    RunFunction(my_context, my_GHFunc_fct_##A, 3, a, b, c); \
+static uintptr_t my_GHFunc_fct_##A = 0;                            \
+static void my_GHFunc_##A(void* a, void* b, void* c)               \
+{                                                                  \
+    RunFunctionFmt(my_context, my_GHFunc_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -532,10 +532,10 @@ static void* findGHFuncFct(void* fct)
 }
 // GHRFunc ...
 #define GO(A)   \
-static uintptr_t my_GHRFunc_fct_##A = 0;                            \
-static int my_GHRFunc_##A(void* a, void* b, void* c)                \
-{                                                                   \
-    return RunFunction(my_context, my_GHRFunc_fct_##A, 3, a, b, c); \
+static uintptr_t my_GHRFunc_fct_##A = 0;                                 \
+static int my_GHRFunc_##A(void* a, void* b, void* c)                     \
+{                                                                        \
+    return RunFunctionFmt(my_context, my_GHRFunc_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -554,10 +554,10 @@ static void* findGHRFuncFct(void* fct)
 }
 // GChildWatchFunc ...
 #define GO(A)   \
-static uintptr_t my_GChildWatchFunc_fct_##A = 0;                        \
-static void my_GChildWatchFunc_##A(int a, int b, void* c)               \
-{                                                                       \
-    RunFunction(my_context, my_GChildWatchFunc_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GChildWatchFunc_fct_##A = 0;                            \
+static void my_GChildWatchFunc_##A(int a, int b, void* c)                   \
+{                                                                           \
+    RunFunctionFmt(my_context, my_GChildWatchFunc_fct_##A, "iip", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -576,10 +576,10 @@ static void* findGChildWatchFuncFct(void* fct)
 }
 // GLogFunc ...
 #define GO(A)   \
-static uintptr_t my_GLogFunc_fct_##A = 0;                           \
-static void my_GLogFunc_##A(void* a, int b, void* c, void* d)       \
-{                                                                   \
-    RunFunction(my_context, my_GLogFunc_fct_##A, 4, a, b, c, d);    \
+static uintptr_t my_GLogFunc_fct_##A = 0;                                \
+static void my_GLogFunc_##A(void* a, int b, void* c, void* d)            \
+{                                                                        \
+    RunFunctionFmt(my_context, my_GLogFunc_fct_##A, "pipp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -606,10 +606,10 @@ static void* reverseGLogFuncFct(void* fct)
 }
 // GPrintFunc ...
 #define GO(A)   \
-static uintptr_t my_GPrintFunc_fct_##A = 0;                     \
-static void my_GPrintFunc_##A(void* a)                          \
-{                                                               \
-    RunFunction(my_context, my_GPrintFunc_fct_##A, 1, a);       \
+static uintptr_t my_GPrintFunc_fct_##A = 0;                    \
+static void my_GPrintFunc_##A(void* a)                         \
+{                                                              \
+    RunFunctionFmt(my_context, my_GPrintFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -636,10 +636,10 @@ static void* reverseGPrintFuncFct(void* fct)
 }
 // GOptionArg ...
 #define GO(A)   \
-static uintptr_t my_GOptionArg_fct_##A = 0;                                     \
-static int my_GOptionArg_##A(void* a, void* b, void* c, void* d)                \
-{                                                                               \
-    return (int)RunFunction(my_context, my_GOptionArg_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_GOptionArg_fct_##A = 0;                                            \
+static int my_GOptionArg_##A(void* a, void* b, void* c, void* d)                       \
+{                                                                                      \
+    return (int)RunFunctionFmt(my_context, my_GOptionArg_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -666,10 +666,10 @@ static void* reverseGOptionArgFct(void* fct)
 }
 // GNodeTraverseFunc ...
 #define GO(A)   \
-static uintptr_t my_GNodeTraverseFunc_fct_##A = 0;                              \
-static int my_GNodeTraverseFunc_##A(void* a, void* b)                           \
-{                                                                               \
-    return (int)RunFunction(my_context, my_GNodeTraverseFunc_fct_##A, 2, a, b); \
+static uintptr_t my_GNodeTraverseFunc_fct_##A = 0;                                    \
+static int my_GNodeTraverseFunc_##A(void* a, void* b)                                 \
+{                                                                                     \
+    return (int)RunFunctionFmt(my_context, my_GNodeTraverseFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -688,10 +688,10 @@ static void* findGNodeTraverseFuncFct(void* fct)
 }
 // GThreadFunc ...
 #define GO(A)   \
-static uintptr_t my_GThreadFunc_fct_##A = 0;                            \
-static void* my_GThreadFunc_##A(void* a)                                \
-{                                                                       \
-    return (void*)RunFunction(my_context, my_GThreadFunc_fct_##A, 1, a);\
+static uintptr_t my_GThreadFunc_fct_##A = 0;                                  \
+static void* my_GThreadFunc_##A(void* a)                                      \
+{                                                                             \
+    return (void*)RunFunctionFmt(my_context, my_GThreadFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -863,7 +863,7 @@ EXPORT void* my_g_main_context_get_poll_func(x64emu_t* emu, void* context)
     // needs to bridge....
     return (void*)AddCheckBridge(my_lib->w.bridge, iFpui, ret, 0, NULL);
 }
-    
+
 EXPORT void my_g_main_context_set_poll_func(x64emu_t* emu, void* context, void* func)
 {
     my->g_main_context_set_poll_func(context, findPollFct(func));
@@ -896,17 +896,17 @@ EXPORT void my_g_hash_table_foreach(x64emu_t* emu, void* table, void* f, void* d
 
 EXPORT uint32_t my_g_hash_table_foreach_remove(x64emu_t* emu, void* table, void* f, void* data)
 {
-    
+
     return my->g_hash_table_foreach_remove(table, findGHRFuncFct(f), data);
 }
 EXPORT uint32_t my_g_hash_table_foreach_steal(x64emu_t* emu, void* table, void* f, void* data)
 {
-    
+
     return my->g_hash_table_foreach_steal(table, findGHRFuncFct(f), data);
 }
 EXPORT void* my_g_hash_table_find(x64emu_t* emu, void* table, void* f, void* data)
 {
-    
+
     return my->g_hash_table_find(table, findGHRFuncFct(f), data);
 }
 
diff --git a/src/wrapped/wrappedgnutls.c b/src/wrapped/wrappedgnutls.c
index cc89e69c..ce6fead1 100755
--- a/src/wrapped/wrappedgnutls.c
+++ b/src/wrapped/wrappedgnutls.c
@@ -35,10 +35,10 @@ GO(4)
 
 // gnutls_log
 #define GO(A)   \
-static uintptr_t my_gnutls_log_fct_##A = 0;                       \
-static void my_gnutls_log_##A(int level, const char* p)           \
-{                                                                 \
-    RunFunction(my_context, my_gnutls_log_fct_##A, 2, level, p);  \
+static uintptr_t my_gnutls_log_fct_##A = 0;                            \
+static void my_gnutls_log_##A(int level, const char* p)                \
+{                                                                      \
+    RunFunctionFmt(my_context, my_gnutls_log_fct_##A, "ip", level, p); \
 }
 SUPER()
 #undef GO
@@ -59,10 +59,10 @@ static void* find_gnutls_log_Fct(void* fct)
 
 // pullpush
 #define GO(A)   \
-static uintptr_t my_pullpush_fct_##A = 0;                                   \
-static long my_pullpush_##A(void* p, void* d, size_t l)                     \
-{                                                                           \
-    return (long)RunFunction(my_context, my_pullpush_fct_##A, 3, p, d, l);  \
+static uintptr_t my_pullpush_fct_##A = 0;                                         \
+static long my_pullpush_##A(void* p, void* d, size_t l)                           \
+{                                                                                 \
+    return (long)RunFunctionFmt(my_context, my_pullpush_fct_##A, "ppL", p, d, l); \
 }
 SUPER()
 #undef GO
@@ -83,10 +83,10 @@ static void* find_pullpush_Fct(void* fct)
 
 // timeout
 #define GO(A)   \
-static uintptr_t my_timeout_fct_##A = 0;                                \
-static int my_timeout_##A(void* p, uint32_t t)                          \
-{                                                                       \
-    return (int)RunFunction(my_context, my_timeout_fct_##A, 2, p, t);   \
+static uintptr_t my_timeout_fct_##A = 0;                                    \
+static int my_timeout_##A(void* p, uint32_t t)                              \
+{                                                                           \
+    return (int)RunFunctionFmt(my_context, my_timeout_fct_##A, "pu", p, t); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedgobject2.c b/src/wrapped/wrappedgobject2.c
index 16f4e688..1295cedd 100755
--- a/src/wrapped/wrappedgobject2.c
+++ b/src/wrapped/wrappedgobject2.c
@@ -67,11 +67,11 @@ static int signal_cb(void* a, void* b, void* c, void* d, void* e)
     }
     printf_log(LOG_DEBUG, "gobject2 Signal called, sig=%p, handler=%p, NArgs=%d\n", sig, sig?(void*)sig->c_handler:NULL, i);
     switch(i) {
-        case 1: return (int)RunFunction(my_context, sig->c_handler, 1, sig->data);
-        case 2: return (int)RunFunction(my_context, sig->c_handler, 2, a, sig->data);
-        case 3: return (int)RunFunction(my_context, sig->c_handler, 3, a, b, sig->data);
-        case 4: return (int)RunFunction(my_context, sig->c_handler, 4, a, b, c, sig->data);
-        case 5: return (int)RunFunction(my_context, sig->c_handler, 5, a, b, c, d, sig->data);
+        case 1: return (int)RunFunctionFmt(my_context, sig->c_handler, "p", sig->data);
+        case 2: return (int)RunFunctionFmt(my_context, sig->c_handler, "pp", a, sig->data);
+        case 3: return (int)RunFunctionFmt(my_context, sig->c_handler, "ppp", a, b, sig->data);
+        case 4: return (int)RunFunctionFmt(my_context, sig->c_handler, "pppp", a, b, c, sig->data);
+        case 5: return (int)RunFunctionFmt(my_context, sig->c_handler, "ppppp", a, b, c, d, sig->data);
     }
     printf_log(LOG_NONE, "Warning, GObject2 signal callback but no data found!\n");
     return 0;
@@ -80,47 +80,47 @@ static int signal_cb_swapped(my_signal_t* sig, void* b, void* c, void* d)
 {
     // data is in front here...
     printf_log(LOG_DEBUG, "gobject2 swaped4 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 4, sig->data, b, c, d);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pppp", sig->data, b, c, d);
 }
 static int signal_cb_5(void* a, void* b, void* c, void* d, my_signal_t* sig)
 {
     printf_log(LOG_DEBUG, "gobject2 5 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 5, a, b, c, d, sig->data);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "ppppp", a, b, c, d, sig->data);
 }
 static int signal_cb_swapped_5(my_signal_t* sig, void* b, void* c, void* d, void* e)
 {
     // data is in front here...
     printf_log(LOG_DEBUG, "gobject2 swaped5 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 5, sig->data, b, c, d, e);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "ppppp", sig->data, b, c, d, e);
 }
 static int signal_cb_6(void* a, void* b, void* c, void* d, void* e, my_signal_t* sig)
 {
     printf_log(LOG_DEBUG, "gobject2 6 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 6, a, b, c, d, e, sig->data);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pppppp", a, b, c, d, e, sig->data);
 }
 static int signal_cb_swapped_6(my_signal_t* sig, void* b, void* c, void* d, void* e, void* f)
 {
     // data is in front here...
     printf_log(LOG_DEBUG, "gobject2 swaped6 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 6, sig->data, b, c, d, e, f);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pppppp", sig->data, b, c, d, e, f);
 }
 static int signal_cb_8(void* a, void* b, void* c, void* d, void* e, void* f, void* g, my_signal_t* sig)
 {
     printf_log(LOG_DEBUG, "gobject2 8 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 8, a, b, c, d, e, f, g, sig->data);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pppppppp", a, b, c, d, e, f, g, sig->data);
 }
 static int signal_cb_swapped_8(my_signal_t* sig, void* b, void* c, void* d, void* e, void* f, void* g, void* h)
 {
     // data is in front here...
     printf_log(LOG_DEBUG, "gobject2 swaped8 Signal called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 8, sig->data, b, c, d, e, f, g, h);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pppppppp", sig->data, b, c, d, e, f, g, h);
 }
 
 static void signal_delete(my_signal_t* sig, void* b)
 {
     uintptr_t d = sig->destroy;
     if(d) {
-        RunFunction(my_context, d, 2, sig->data, b);
+        RunFunctionFmt(my_context, d, "pp", sig->data, b);
     }
     printf_log(LOG_DEBUG, "gobject2 Signal deleted, sig=%p, destroy=%p\n", sig, (void*)d);
     free(sig);
@@ -267,10 +267,10 @@ GO(11)  \
 GO(12)  \
 
 #define GO(A)   \
-static uintptr_t my_copy_fct_##A = 0;   \
-static void* my_copy_##A(void* data)     \
-{                                       \
-    return (void*)RunFunction(my_context, my_copy_fct_##A, 1, data);\
+static uintptr_t my_copy_fct_##A = 0;                                     \
+static void* my_copy_##A(void* data)                                      \
+{                                                                         \
+    return (void*)RunFunctionFmt(my_context, my_copy_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -288,10 +288,10 @@ static void* findCopyFct(void* fct)
 }
 
 #define GO(A)   \
-static uintptr_t my_free_fct_##A = 0;   \
-static void my_free_##A(void* data)     \
-{                                       \
-    RunFunction(my_context, my_free_fct_##A, 1, data);\
+static uintptr_t my_free_fct_##A = 0;                       \
+static void my_free_##A(void* data)                         \
+{                                                           \
+    RunFunctionFmt(my_context, my_free_fct_##A, "p", data); \
 }
 SUPER()
 #undef GO
@@ -309,10 +309,10 @@ static void* findFreeFct(void* fct)
 }
 // GSignalAccumulator
 #define GO(A)   \
-static uintptr_t my_accumulator_fct_##A = 0;   \
-static int my_accumulator_##A(void* ihint, void* return_accu, void* handler_return, void* data)     \
-{                                       \
-    return RunFunction(my_context, my_accumulator_fct_##A, 4, ihint, return_accu, handler_return, data);\
+static uintptr_t my_accumulator_fct_##A = 0;                                                                     \
+static int my_accumulator_##A(void* ihint, void* return_accu, void* handler_return, void* data)                  \
+{                                                                                                                \
+    return RunFunctionFmt(my_context, my_accumulator_fct_##A, "pppp", ihint, return_accu, handler_return, data); \
 }
 SUPER()
 #undef GO
@@ -332,10 +332,10 @@ static void* findAccumulatorFct(void* fct)
 
 // GClosureMarshal
 #define GO(A)   \
-static uintptr_t my_marshal_fct_##A = 0;   \
+static uintptr_t my_marshal_fct_##A = 0;                                                                        \
 static void my_marshal_##A(void* closure, void* return_value, uint32_t n, void* values, void* hint, void* data) \
 {                                                                                                               \
-    RunFunction(my_context, my_marshal_fct_##A, 6, closure, return_value, n, values, hint, data);               \
+    RunFunctionFmt(my_context, my_marshal_fct_##A, "ppuppp", closure, return_value, n, values, hint, data);     \
 }
 SUPER()
 #undef GO
@@ -355,10 +355,10 @@ static void* findMarshalFct(void* fct)
 
 // GClosureNotify
 #define GO(A)   \
-static uintptr_t my_GClosureNotify_fct_##A = 0;   \
-static int my_GClosureNotify_func_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_GClosureNotify_fct_##A, 2, a, b);\
+static uintptr_t my_GClosureNotify_fct_##A = 0;                               \
+static int my_GClosureNotify_func_##A(void* a, void* b)                       \
+{                                                                             \
+    return RunFunctionFmt(my_context, my_GClosureNotify_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -378,10 +378,10 @@ static void* findGClosureNotify_Fct(void* fct)
 
 // GValueTransform
 #define GO(A)   \
-static uintptr_t my_valuetransform_fct_##A = 0;                     \
-static void my_valuetransform_##A(void* src, void* dst)            \
-{                                                                   \
-    RunFunction(my_context, my_valuetransform_fct_##A, 2, src, dst);\
+static uintptr_t my_valuetransform_fct_##A = 0;                            \
+static void my_valuetransform_##A(void* src, void* dst)                    \
+{                                                                          \
+    RunFunctionFmt(my_context, my_valuetransform_fct_##A, "pp", src, dst); \
 }
 SUPER()
 #undef GO
@@ -401,10 +401,10 @@ static void* findValueTransformFct(void* fct)
 
 // GDestroyFunc ...
 #define GO(A)   \
-static uintptr_t my_destroyfunc_fct_##A = 0;   \
-static int my_destroyfunc_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_destroyfunc_fct_##A, 2, a, b);\
+static uintptr_t my_destroyfunc_fct_##A = 0;                               \
+static int my_destroyfunc_##A(void* a, void* b)                            \
+{                                                                          \
+    return RunFunctionFmt(my_context, my_destroyfunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -424,10 +424,10 @@ static void* findDestroyFct(void* fct)
 
 // GWeakNotify
 #define GO(A)   \
-static uintptr_t my_weaknotifyfunc_fct_##A = 0;   \
-static int my_weaknotifyfunc_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_weaknotifyfunc_fct_##A, 2, a, b);\
+static uintptr_t my_weaknotifyfunc_fct_##A = 0;                               \
+static int my_weaknotifyfunc_##A(void* a, void* b)                            \
+{                                                                             \
+    return RunFunctionFmt(my_context, my_weaknotifyfunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -447,10 +447,10 @@ static void* findWeakNotifyFct(void* fct)
 
 // GCallback  (generic function with 6 arguments, hopefully it's enough)
 #define GO(A)   \
-static uintptr_t my_GCallback_fct_##A = 0;                                             \
-static void* my_GCallback_##A(void* a, void* b, void* c, void* d, void* e, void* f)    \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_GCallback_fct_##A, 6, a, b, c, d, e, f);  \
+static uintptr_t my_GCallback_fct_##A = 0;                                                      \
+static void* my_GCallback_##A(void* a, void* b, void* c, void* d, void* e, void* f)             \
+{                                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_GCallback_fct_##A, "pppppp", a, b, c, d, e, f); \
 }
 SUPER()
 #undef GO
@@ -481,32 +481,32 @@ typedef struct my_GParamSpecTypeInfo_s {
   int       (*values_cmp)       (void* pspec, void* value1, void* value2);
 } my_GParamSpecTypeInfo_t;
 
-#define GO(A) \
+#define GO(A)   \
 static my_GParamSpecTypeInfo_t     my_GParamSpecTypeInfo_##A = {0};   \
 static my_GParamSpecTypeInfo_t   *ref_GParamSpecTypeInfo_##A = NULL;
 SUPER()
 #undef GO
 // then the static functions callback that may be used with the structure, but dispatch also have a callback...
 #define GO(A)   \
-static uintptr_t fct_funcs_instance_init_##A = 0;                   \
-static void my_funcs_instance_init_##A(void* pspec) {               \
-    RunFunction(my_context, fct_funcs_instance_init_##A, 1, pspec); \
+static uintptr_t fct_funcs_instance_init_##A = 0;                           \
+static void my_funcs_instance_init_##A(void* pspec) {                       \
+    RunFunctionFmt(my_context, fct_funcs_instance_init_##A, "p", pspec);    \
 }   \
-static uintptr_t fct_funcs_finalize_##A = 0;                        \
-static void my_funcs_finalize_##A(void* pspec) {                    \
-    RunFunction(my_context, fct_funcs_finalize_##A, 1, pspec);      \
+static uintptr_t fct_funcs_finalize_##A = 0;                                \
+static void my_funcs_finalize_##A(void* pspec) {                            \
+    RunFunctionFmt(my_context, fct_funcs_finalize_##A, "p", pspec);         \
 }   \
-static uintptr_t fct_funcs_value_set_default_##A = 0;               \
-static void my_funcs_value_set_default_##A(void* pspec, void* value) {          \
-    RunFunction(my_context, fct_funcs_value_set_default_##A, 2, pspec, value);  \
+static uintptr_t fct_funcs_value_set_default_##A = 0;                   \
+static void my_funcs_value_set_default_##A(void* pspec, void* value) {  \
+    RunFunctionFmt(my_context, fct_funcs_value_set_default_##A, "pp", pspec, value);    \
 }   \
-static uintptr_t fct_funcs_value_validate_##A = 0;                  \
-static int my_funcs_value_validate_##A(void* pspec, void* value) {  \
-    return (int)RunFunction(my_context, fct_funcs_value_validate_##A, 2, pspec, value); \
+static uintptr_t fct_funcs_value_validate_##A = 0;                      \
+static int my_funcs_value_validate_##A(void* pspec, void* value) {      \
+    return (int)RunFunctionFmt(my_context, fct_funcs_value_validate_##A, "pp", pspec, value); \
 }   \
-static uintptr_t fct_funcs_values_cmp_##A = 0;                      \
+static uintptr_t fct_funcs_values_cmp_##A = 0;                          \
 static int my_funcs_values_cmp_##A(void* pspec, void* value1, void* value2) {   \
-    return (int)RunFunction(my_context, fct_funcs_values_cmp_##A, 3, pspec, value1, value2);    \
+    return (int)RunFunctionFmt(my_context, fct_funcs_values_cmp_##A, "ppp", pspec, value1, value2); \
 }
 
 SUPER()
@@ -540,10 +540,10 @@ static my_GParamSpecTypeInfo_t* findFreeGParamSpecTypeInfo(my_GParamSpecTypeInfo
 
 // GInterfaceInitFunc
 #define GO(A)   \
-static uintptr_t my_GInterfaceInitFunc_fct_##A = 0;                     \
-static void my_GInterfaceInitFunc_##A(void* src, void* dst)            \
-{                                                                   \
-    RunFunction(my_context, my_GInterfaceInitFunc_fct_##A, 2, src, dst);\
+static uintptr_t my_GInterfaceInitFunc_fct_##A = 0;                             \
+static void my_GInterfaceInitFunc_##A(void* src, void* dst)                     \
+{                                                                               \
+    RunFunctionFmt(my_context, my_GInterfaceInitFunc_fct_##A, "pp", src, dst);  \
 }
 SUPER()
 #undef GO
@@ -562,10 +562,10 @@ static void* findGInterfaceInitFuncFct(void* fct)
 }
 // GInterfaceFinalizeFunc
 #define GO(A)   \
-static uintptr_t my_GInterfaceFinalizeFunc_fct_##A = 0;                     \
-static void my_GInterfaceFinalizeFunc_##A(void* src, void* dst)            \
-{                                                                   \
-    RunFunction(my_context, my_GInterfaceFinalizeFunc_fct_##A, 2, src, dst);\
+static uintptr_t my_GInterfaceFinalizeFunc_fct_##A = 0;                             \
+static void my_GInterfaceFinalizeFunc_##A(void* src, void* dst)                     \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_GInterfaceFinalizeFunc_fct_##A, "pp", src, dst);  \
 }
 SUPER()
 #undef GO
@@ -584,10 +584,10 @@ static void* findGInterfaceFinalizeFuncFct(void* fct)
 }
 // compare
 #define GO(A)   \
-static uintptr_t my_compare_fct_##A = 0;                                \
-static int my_compare_##A(void* a, void* b, void* data)                 \
-{                                                                       \
-    return RunFunction(my_context, my_compare_fct_##A, 3, a, b, data);  \
+static uintptr_t my_compare_fct_##A = 0;                                        \
+static int my_compare_##A(void* a, void* b, void* data)                         \
+{                                                                               \
+    return RunFunctionFmt(my_context, my_compare_fct_##A, "ppp", a, b, data);   \
 }
 SUPER()
 #undef GO
@@ -623,7 +623,7 @@ EXPORT int my_g_boxed_type_register_static(x64emu_t* emu, void* name, void* boxe
 EXPORT uint32_t my_g_signal_new(x64emu_t* emu, void* name, size_t itype, int flags, uint32_t offset, void* acc, void* accu_data, void* marsh, size_t rtype, uint32_t n, void** b)
 {
     printf_log(LOG_DEBUG, "g_signal_new for \"%s\", with offset=%d and %d args\n", (const char*)name, offset, n);
-    
+
     void* cb_acc = findAccumulatorFct(acc);
     void* cb_marsh = findMarshalFct(marsh);
     my_add_signal_offset(itype, offset, n); // register the signal for later use
@@ -644,7 +644,7 @@ EXPORT uint32_t my_g_signal_new(x64emu_t* emu, void* name, size_t itype, int fla
 EXPORT uint32_t my_g_signal_newv(x64emu_t* emu, void* name, size_t itype, int flags, void* closure, void* acc, void* accu_data, void* marsh, size_t rtype, uint32_t n, void* types)
 {
     printf_log(LOG_DEBUG, "g_signal_newv for \"%s\", with %d args\n", (const char*)name, n);
-    
+
     return my->g_signal_newv(name, itype, flags, closure, findAccumulatorFct(acc), accu_data, findMarshalFct(marsh), rtype, n, types);
 }
 
@@ -732,7 +732,7 @@ EXPORT void my_g_value_register_transform_func(x64emu_t* emu, size_t src, size_t
 static int my_signal_emission_hook(void* ihint, uint32_t n, void* values, my_signal_t* sig)
 {
     printf_log(LOG_DEBUG, "gobject2 Signal Emission Hook called, sig=%p\n", sig);
-    return (int)RunFunction(my_context, sig->c_handler, 4, ihint, n, values, sig->data);
+    return (int)RunFunctionFmt(my_context, sig->c_handler, "pupp", ihint, n, values, sig->data);
 }
 EXPORT unsigned long my_g_signal_add_emission_hook(x64emu_t* emu, uint32_t signal, void* detail, void* f, void* data, void* notify)
 {
diff --git a/src/wrapped/wrappedgstreamer.c b/src/wrapped/wrappedgstreamer.c
index 7c22cc6c..2ce5adc5 100644
--- a/src/wrapped/wrappedgstreamer.c
+++ b/src/wrapped/wrappedgstreamer.c
@@ -50,10 +50,10 @@ GO(3)   \
 
 // GDestroyFunc ...
 #define GO(A)   \
-static uintptr_t my_destroyfunc_fct_##A = 0;   \
-static int my_destroyfunc_##A(void* a, void* b)     \
-{                                       \
-    return RunFunction(my_context, my_destroyfunc_fct_##A, 2, a, b);\
+static uintptr_t my_destroyfunc_fct_##A = 0;                                \
+static int my_destroyfunc_##A(void* a, void* b)                             \
+{                                                                           \
+    return RunFunctionFmt(my_context, my_destroyfunc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -74,10 +74,10 @@ static void* findDestroyFct(void* fct)
 }
 //GstPadActivateModeFunction
 #define GO(A)   \
-static uintptr_t my_GstPadActivateModeFunction_fct_##A = 0;                                     \
-static int my_GstPadActivateModeFunction_##A(void* a, void* b, int c, int d)                    \
-{                                                                                               \
-    return (int)RunFunction(my_context, my_GstPadActivateModeFunction_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_GstPadActivateModeFunction_fct_##A = 0;                                             \
+static int my_GstPadActivateModeFunction_##A(void* a, void* b, int c, int d)                            \
+{                                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_GstPadActivateModeFunction_fct_##A, "ppii", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -97,10 +97,10 @@ static void* findGstPadActivateModeFunctionFct(void* fct)
 }
 //GstPadQueryFunction
 #define GO(A)   \
-static uintptr_t my_GstPadQueryFunction_fct_##A = 0;                                    \
-static int my_GstPadQueryFunction_##A(void* a, void* b, void* c)                        \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GstPadQueryFunction_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GstPadQueryFunction_fct_##A = 0;                                        \
+static int my_GstPadQueryFunction_##A(void* a, void* b, void* c)                            \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GstPadQueryFunction_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -120,10 +120,10 @@ static void* findGstPadQueryFunctionFct(void* fct)
 }
 //GstPadGetRangeFunction
 #define GO(A)   \
-static uintptr_t my_GstPadGetRangeFunction_fct_##A = 0;                                         \
-static int my_GstPadGetRangeFunction_##A(void* a, void* b, uint64_t c, uint32_t d, void* e)     \
-{                                                                                               \
-    return (int)RunFunction(my_context, my_GstPadGetRangeFunction_fct_##A, 5, a, b, c, d, e);   \
+static uintptr_t my_GstPadGetRangeFunction_fct_##A = 0;                                                 \
+static int my_GstPadGetRangeFunction_##A(void* a, void* b, uint64_t c, uint32_t d, void* e)             \
+{                                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_GstPadGetRangeFunction_fct_##A, "ppUup", a, b, c, d, e);  \
 }
 SUPER()
 #undef GO
@@ -143,10 +143,10 @@ static void* findGstPadGetRangeFunctionFct(void* fct)
 }
 //GstPadChainFunction
 #define GO(A)   \
-static uintptr_t my_GstPadChainFunction_fct_##A = 0;                                    \
-static int my_GstPadChainFunction_##A(void* a, void* b, void* c)                        \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GstPadChainFunction_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GstPadChainFunction_fct_##A = 0;                                        \
+static int my_GstPadChainFunction_##A(void* a, void* b, void* c)                            \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GstPadChainFunction_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -166,10 +166,10 @@ static void* findGstPadChainFunctionFct(void* fct)
 }
 //GstPadEventFunction
 #define GO(A)   \
-static uintptr_t my_GstPadEventFunction_fct_##A = 0;                                    \
-static int my_GstPadEventFunction_##A(void* a, void* b, void* c)                        \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GstPadEventFunction_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GstPadEventFunction_fct_##A = 0;                                        \
+static int my_GstPadEventFunction_##A(void* a, void* b, void* c)                            \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GstPadEventFunction_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -187,10 +187,10 @@ static void* findGstPadEventFunctionFct(void* fct)
 }
 //GstBusSyncHandler
 #define GO(A)   \
-static uintptr_t my_GstBusSyncHandler_fct_##A = 0;                                    \
-static int my_GstBusSyncHandler_##A(void* a, void* b, void* c)                        \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GstBusSyncHandler_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GstBusSyncHandler_fct_##A = 0;                                          \
+static int my_GstBusSyncHandler_##A(void* a, void* b, void* c)                              \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GstBusSyncHandler_fct_##A, "ppp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -209,10 +209,10 @@ static void* findGstBusSyncHandlerFct(void* fct)
 
 //GstPluginFeatureFilter
 #define GO(A)   \
-static uintptr_t my_GstPluginFeatureFilter_fct_##A = 0;                                 \
-static int my_GstPluginFeatureFilter_##A(void* a, void* b)                              \
-{                                                                                       \
-    return (int)RunFunction(my_context, my_GstPluginFeatureFilter_fct_##A, 2, a, b);    \
+static uintptr_t my_GstPluginFeatureFilter_fct_##A = 0;                                     \
+static int my_GstPluginFeatureFilter_##A(void* a, void* b)                                  \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_GstPluginFeatureFilter_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -332,7 +332,7 @@ EXPORT void* my_gst_buffer_new_wrapped_full(x64emu_t* emu, uint32_t f, void* dat
 
 EXPORT void* my_gst_structure_new(x64emu_t* emu, void* name, void* first, uint64_t* b)
 {
-    if(!first)    
+    if(!first)
         return my->gst_structure_new_empty(name);
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     return my->gst_structure_new_valist(name, first, VARARGS);
diff --git a/src/wrapped/wrappedgtk3.c b/src/wrapped/wrappedgtk3.c
index b2e459d1..f8493e84 100755
--- a/src/wrapped/wrappedgtk3.c
+++ b/src/wrapped/wrappedgtk3.c
@@ -99,10 +99,10 @@ GO(3)
 
 // GtkMenuDetachFunc
 #define GO(A)   \
-static uintptr_t my_menudetach_fct_##A = 0;   \
-static void my_menudetach_##A(void* widget, void* menu)     \
-{                                       \
-    RunFunction(my_context, my_menudetach_fct_##A, 2, widget, menu);\
+static uintptr_t my_menudetach_fct_##A = 0;                                 \
+static void my_menudetach_##A(void* widget, void* menu)                     \
+{                                                                           \
+    RunFunctionFmt(my_context, my_menudetach_fct_##A, "pp", widget, menu);  \
 }
 SUPER()
 #undef GO
@@ -122,10 +122,10 @@ static void* findMenuDetachFct(void* fct)
 
 // GtkMenuPositionFunc
 #define GO(A)   \
-static uintptr_t my_menuposition_fct_##A = 0;   \
-static void my_menuposition_##A(void* menu, void* x, void* y, void* push_in, void* data)     \
-{                                       \
-    RunFunction(my_context, my_menuposition_fct_##A, 5, menu, x, y, push_in, data);\
+static uintptr_t my_menuposition_fct_##A = 0;                                                   \
+static void my_menuposition_##A(void* menu, void* x, void* y, void* push_in, void* data)        \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_menuposition_fct_##A, "ppppp", menu, x, y, push_in, data);    \
 }
 SUPER()
 #undef GO
@@ -145,10 +145,10 @@ static void* findMenuPositionFct(void* fct)
 
 // GtkFunction
 #define GO(A)   \
-static uintptr_t my3_gtkfunction_fct_##A = 0;   \
-static int my3_gtkfunction_##A(void* data)     \
-{                                       \
-    return RunFunction(my_context, my3_gtkfunction_fct_##A, 1, data);\
+static uintptr_t my3_gtkfunction_fct_##A = 0;                               \
+static int my3_gtkfunction_##A(void* data)                                  \
+{                                                                           \
+    return RunFunctionFmt(my_context, my3_gtkfunction_fct_##A, "p", data);  \
 }
 SUPER()
 #undef GO
@@ -168,10 +168,10 @@ static void* findGtkFunctionFct(void* fct)
 
 // GtkClipboardGetFunc
 #define GO(A)   \
-static uintptr_t my_clipboardget_fct_##A = 0;   \
-static void my_clipboardget_##A(void* clipboard, void* selection, uint32_t info, void* data)     \
-{                                       \
-    RunFunction(my_context, my_clipboardget_fct_##A, 4, clipboard, selection, info, data);\
+static uintptr_t my_clipboardget_fct_##A = 0;                                                       \
+static void my_clipboardget_##A(void* clipboard, void* selection, uint32_t info, void* data)        \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_clipboardget_fct_##A, "ppup", clipboard, selection, info, data);  \
 }
 SUPER()
 #undef GO
@@ -191,10 +191,10 @@ static void* findClipboadGetFct(void* fct)
 
 // GtkClipboardClearFunc
 #define GO(A)   \
-static uintptr_t my_clipboardclear_fct_##A = 0;   \
-static void my_clipboardclear_##A(void* clipboard, void* data)     \
-{                                       \
-    RunFunction(my_context, my_clipboardclear_fct_##A, 2, clipboard, data);\
+static uintptr_t my_clipboardclear_fct_##A = 0;                                     \
+static void my_clipboardclear_##A(void* clipboard, void* data)                      \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_clipboardclear_fct_##A, "pp", clipboard, data);   \
 }
 SUPER()
 #undef GO
@@ -213,11 +213,11 @@ static void* findClipboadClearFct(void* fct)
 }
 
 // GtkCallback
-#define GO(A)   \
-static uintptr_t my3_gtkcallback_fct_##A = 0;   \
-static void my3_gtkcallback_##A(void* widget, void* data)     \
-{                                       \
-    RunFunction(my_context, my3_gtkcallback_fct_##A, 2, widget, data);\
+#define GO(A)                                                                   \
+static uintptr_t my3_gtkcallback_fct_##A = 0;                                   \
+static void my3_gtkcallback_##A(void* widget, void* data)                       \
+{                                                                               \
+    RunFunctionFmt(my_context, my3_gtkcallback_fct_##A, "pp", widget, data);    \
 }
 SUPER()
 #undef GO
@@ -237,10 +237,10 @@ static void* findGtkCallbackFct(void* fct)
 
 // GtkTextCharPredicate
 #define GO(A)   \
-static uintptr_t my_textcharpredicate_fct_##A = 0;   \
-static int my_textcharpredicate_##A(uint32_t ch, void* data)     \
-{                                       \
-    return (int)RunFunction(my_context, my_textcharpredicate_fct_##A, 2, ch, data);\
+static uintptr_t my_textcharpredicate_fct_##A = 0;                                          \
+static int my_textcharpredicate_##A(uint32_t ch, void* data)                                \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_textcharpredicate_fct_##A, "up", ch, data);   \
 }
 SUPER()
 #undef GO
@@ -260,10 +260,10 @@ static void* findGtkTextCharPredicateFct(void* fct)
 
 // Toolbar
 #define GO(A)   \
-static uintptr_t my_toolbar_fct_##A = 0;   \
-static void my_toolbar_##A(void* widget, void* data)     \
-{                                       \
-    RunFunction(my_context, my_toolbar_fct_##A, 2, widget, data);\
+static uintptr_t my_toolbar_fct_##A = 0;                                \
+static void my_toolbar_##A(void* widget, void* data)                    \
+{                                                                       \
+    RunFunctionFmt(my_context, my_toolbar_fct_##A, "pp", widget, data); \
 }
 SUPER()
 #undef GO
@@ -283,10 +283,10 @@ static void* findToolbarFct(void* fct)
 
 // Builder
 #define GO(A)   \
-static uintptr_t my_builderconnect_fct_##A = 0;   \
-static void my_builderconnect_##A(void* builder, void* object, void* signal, void* handler, void* connect, int flags, void* data)     \
-{                                       \
-    RunFunction(my_context, my_builderconnect_fct_##A, 7, builder, object, signal, handler, connect, flags, data);\
+static uintptr_t my_builderconnect_fct_##A = 0;                                                                                     \
+static void my_builderconnect_##A(void* builder, void* object, void* signal, void* handler, void* connect, int flags, void* data)   \
+{                                                                                                                                   \
+    RunFunctionFmt(my_context, my_builderconnect_fct_##A, "pppppip", builder, object, signal, handler, connect, flags, data);       \
 }
 SUPER()
 #undef GO
@@ -306,10 +306,10 @@ static void* findBuilderConnectFct(void* fct)
 
 // GtkTreeViewSearchEqualFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeViewSearchEqualFunc_fct_##A = 0;                                                     \
-static int my_GtkTreeViewSearchEqualFunc_##A(void* model, int column, void* key, void* iter, void* data)        \
-{                                                                                                               \
-    return RunFunction(my_context, my_GtkTreeViewSearchEqualFunc_fct_##A, 5, model, column, key, iter, data);   \
+static uintptr_t my_GtkTreeViewSearchEqualFunc_fct_##A = 0;                                                             \
+static int my_GtkTreeViewSearchEqualFunc_##A(void* model, int column, void* key, void* iter, void* data)                \
+{                                                                                                                       \
+    return RunFunctionFmt(my_context, my_GtkTreeViewSearchEqualFunc_fct_##A, "pippp", model, column, key, iter, data);  \
 }
 SUPER()
 #undef GO
@@ -328,10 +328,10 @@ static void* findGtkTreeViewSearchEqualFuncFct(void* fct)
 }
 // GtkTreeCellDataFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeCellDataFunc_fct_##A = 0;                                                \
-static void my_GtkTreeCellDataFunc_##A(void* tree, void* cell, void* model, void* iter, void* data) \
-{                                                                                                   \
-    RunFunction(my_context, my_GtkTreeCellDataFunc_fct_##A, 5, tree, cell, model, iter, data);      \
+static uintptr_t my_GtkTreeCellDataFunc_fct_##A = 0;                                                    \
+static void my_GtkTreeCellDataFunc_##A(void* tree, void* cell, void* model, void* iter, void* data)     \
+{                                                                                                       \
+    RunFunctionFmt(my_context, my_GtkTreeCellDataFunc_fct_##A, "ppppp", tree, cell, model, iter, data); \
 }
 SUPER()
 #undef GO
@@ -351,10 +351,10 @@ static void* findGtkTreeCellDataFuncFct(void* fct)
 
 // GDestroyNotify
 #define GO(A)   \
-static uintptr_t my_GDestroyNotify_fct_##A = 0;                     \
-static void my_GDestroyNotify_##A(void* data)                       \
-{                                                                   \
-    RunFunction(my_context, my_GDestroyNotify_fct_##A, 1, data);    \
+static uintptr_t my_GDestroyNotify_fct_##A = 0;                         \
+static void my_GDestroyNotify_##A(void* data)                           \
+{                                                                       \
+    RunFunctionFmt(my_context, my_GDestroyNotify_fct_##A, "p", data);   \
 }
 SUPER()
 #undef GO
@@ -374,10 +374,10 @@ static void* findGDestroyNotifyFct(void* fct)
 
 // GtkTreeIterCompareFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeIterCompareFunc_fct_##A = 0;                                         \
-static int my_GtkTreeIterCompareFunc_##A(void* model, void* a, void* b, void* data)             \
-{                                                                                               \
-    return RunFunction(my_context, my_GtkTreeIterCompareFunc_fct_##A, 4, model, a, b, data);    \
+static uintptr_t my_GtkTreeIterCompareFunc_fct_##A = 0;                                                 \
+static int my_GtkTreeIterCompareFunc_##A(void* model, void* a, void* b, void* data)                     \
+{                                                                                                       \
+    return RunFunctionFmt(my_context, my_GtkTreeIterCompareFunc_fct_##A, "pppp", model, a, b, data);    \
 }
 SUPER()
 #undef GO
@@ -397,10 +397,10 @@ static void* findGtkTreeIterCompareFuncFct(void* fct)
 
 // GtkPrinterFunc
 #define GO(A)   \
-static uintptr_t my_GtkPrinterFunc_fct_##A = 0;                                     \
-static int my_GtkPrinterFunc_##A(void* printer, void* data)                         \
-{                                                                                   \
-    return RunFunction(my_context, my_GtkPrinterFunc_fct_##A, 2, printer, data);    \
+static uintptr_t my_GtkPrinterFunc_fct_##A = 0;                                         \
+static int my_GtkPrinterFunc_##A(void* printer, void* data)                             \
+{                                                                                       \
+    return RunFunctionFmt(my_context, my_GtkPrinterFunc_fct_##A, "pp", printer, data);  \
 }
 SUPER()
 #undef GO
@@ -420,10 +420,10 @@ static void* findGtkPrinterFuncFct(void* fct)
 
 // GtkPrintJobCompleteHunc
 #define GO(A)   \
-static uintptr_t my_GtkPrintJobCompleteHunc_fct_##A = 0;                                \
-static void my_GtkPrintJobCompleteHunc_##A(void* job, void* data, void* error)          \
-{                                                                                       \
-    RunFunction(my_context, my_GtkPrintJobCompleteHunc_fct_##A, 3, job, data, error);   \
+static uintptr_t my_GtkPrintJobCompleteHunc_fct_##A = 0;                                        \
+static void my_GtkPrintJobCompleteHunc_##A(void* job, void* data, void* error)                  \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_GtkPrintJobCompleteHunc_fct_##A, "ppp", job, data, error);    \
 }
 SUPER()
 #undef GO
@@ -533,7 +533,7 @@ EXPORT int my3_gtk_clipboard_set_with_owner(x64emu_t* emu, void* clipboard, void
 
 static void* my_translate_func(void* path, my_signal_t* sig)
 {
-    return (void*)RunFunction(my_context, sig->c_handler, 2, path, sig->data);
+    return (void*)RunFunctionFmt(my_context, sig->c_handler, "pp", path, sig->data);
 }
 
 EXPORT void my3_gtk_stock_set_translate_func(x64emu_t* emu, void* domain, void* f, void* data, void* notify)
@@ -639,7 +639,7 @@ typedef struct my_connectargs_s {
 //defined in gobject2...
 uintptr_t my_g_signal_connect_object(x64emu_t* emu, void* instance, void* detailed, void* c_handler, void* object, uint32_t flags);
 uintptr_t my_g_signal_connect_data(x64emu_t* emu, void* instance, void* detailed, void* c_handler, void* data, void* closure, uint32_t flags);
-static void my3_gtk_builder_connect_signals_default(void* builder, void* object, 
+static void my3_gtk_builder_connect_signals_default(void* builder, void* object,
                                                     char* signal_name, char* handler_name,
                                                     void* connect_object, uint32_t flags, my_connectargs_t* args)
 {
diff --git a/src/wrapped/wrappedgtkx112.c b/src/wrapped/wrappedgtkx112.c
index 93a29bc2..7d6fdf3a 100755
--- a/src/wrapped/wrappedgtkx112.c
+++ b/src/wrapped/wrappedgtkx112.c
@@ -150,10 +150,10 @@ GO(39)  \
 
 // GtkMenuDetachFunc
 #define GO(A)   \
-static uintptr_t my_menudetach_fct_##A = 0;   \
-static void my_menudetach_##A(void* widget, void* menu)     \
-{                                       \
-    RunFunction(my_context, my_menudetach_fct_##A, 2, widget, menu);\
+static uintptr_t my_menudetach_fct_##A = 0;                                 \
+static void my_menudetach_##A(void* widget, void* menu)                     \
+{                                                                           \
+    RunFunctionFmt(my_context, my_menudetach_fct_##A, "pp", widget, menu);  \
 }
 SUPER()
 #undef GO
@@ -173,10 +173,10 @@ static void* findMenuDetachFct(void* fct)
 
 // GtkMenuPositionFunc
 #define GO(A)   \
-static uintptr_t my_menuposition_fct_##A = 0;   \
-static void my_menuposition_##A(void* menu, void* x, void* y, void* push_in, void* data)     \
-{                                       \
-    RunFunction(my_context, my_menuposition_fct_##A, 5, menu, x, y, push_in, data);\
+static uintptr_t my_menuposition_fct_##A = 0;                                                   \
+static void my_menuposition_##A(void* menu, void* x, void* y, void* push_in, void* data)        \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_menuposition_fct_##A, "ppppp", menu, x, y, push_in, data);    \
 }
 SUPER()
 #undef GO
@@ -196,10 +196,10 @@ static void* findMenuPositionFct(void* fct)
 
 // GtkFunction
 #define GO(A)   \
-static uintptr_t my_gtkfunction_fct_##A = 0;   \
-static int my_gtkfunction_##A(void* data)     \
-{                                       \
-    return RunFunction(my_context, my_gtkfunction_fct_##A, 1, data);\
+static uintptr_t my_gtkfunction_fct_##A = 0;                                \
+static int my_gtkfunction_##A(void* data)                                   \
+{                                                                           \
+    return RunFunctionFmt(my_context, my_gtkfunction_fct_##A, "p", data);   \
 }
 SUPER()
 #undef GO
@@ -219,10 +219,10 @@ static void* findGtkFunctionFct(void* fct)
 
 // GtkClipboardGetFunc
 #define GO(A)   \
-static uintptr_t my_clipboardget_fct_##A = 0;   \
-static void my_clipboardget_##A(void* clipboard, void* selection, uint32_t info, void* data)     \
-{                                       \
-    RunFunction(my_context, my_clipboardget_fct_##A, 4, clipboard, selection, info, data);\
+static uintptr_t my_clipboardget_fct_##A = 0;                                                       \
+static void my_clipboardget_##A(void* clipboard, void* selection, uint32_t info, void* data)        \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_clipboardget_fct_##A, "ppup", clipboard, selection, info, data);  \
 }
 SUPER()
 #undef GO
@@ -242,10 +242,10 @@ static void* findClipboadGetFct(void* fct)
 
 // GtkClipboardClearFunc
 #define GO(A)   \
-static uintptr_t my_clipboardclear_fct_##A = 0;   \
-static void my_clipboardclear_##A(void* clipboard, void* data)     \
-{                                       \
-    RunFunction(my_context, my_clipboardclear_fct_##A, 2, clipboard, data);\
+static uintptr_t my_clipboardclear_fct_##A = 0;                                     \
+static void my_clipboardclear_##A(void* clipboard, void* data)                      \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_clipboardclear_fct_##A, "pp", clipboard, data);   \
 }
 SUPER()
 #undef GO
@@ -265,10 +265,10 @@ static void* findClipboadClearFct(void* fct)
 
 // GtkCallback
 #define GO(A)   \
-static uintptr_t my_gtkcallback_fct_##A = 0;   \
-static void my_gtkcallback_##A(void* widget, void* data)     \
-{                                       \
-    RunFunction(my_context, my_gtkcallback_fct_##A, 2, widget, data);\
+static uintptr_t my_gtkcallback_fct_##A = 0;                                \
+static void my_gtkcallback_##A(void* widget, void* data)                    \
+{                                                                           \
+    RunFunctionFmt(my_context, my_gtkcallback_fct_##A, "pp", widget, data); \
 }
 SUPER()
 #undef GO
@@ -288,10 +288,10 @@ static void* findGtkCallbackFct(void* fct)
 
 // GtkTextCharPredicate
 #define GO(A)   \
-static uintptr_t my_textcharpredicate_fct_##A = 0;   \
-static int my_textcharpredicate_##A(uint32_t ch, void* data)     \
-{                                       \
-    return (int)RunFunction(my_context, my_textcharpredicate_fct_##A, 2, ch, data);\
+static uintptr_t my_textcharpredicate_fct_##A = 0;                                          \
+static int my_textcharpredicate_##A(uint32_t ch, void* data)                                \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_textcharpredicate_fct_##A, "up", ch, data);   \
 }
 SUPER()
 #undef GO
@@ -311,10 +311,10 @@ static void* findGtkTextCharPredicateFct(void* fct)
 
 // Toolbar
 #define GO(A)   \
-static uintptr_t my_toolbar_fct_##A = 0;   \
-static void my_toolbar_##A(void* widget, void* data)     \
-{                                       \
-    RunFunction(my_context, my_toolbar_fct_##A, 2, widget, data);\
+static uintptr_t my_toolbar_fct_##A = 0;                                \
+static void my_toolbar_##A(void* widget, void* data)                    \
+{                                                                       \
+    RunFunctionFmt(my_context, my_toolbar_fct_##A, "pp", widget, data); \
 }
 SUPER()
 #undef GO
@@ -334,10 +334,10 @@ static void* findToolbarFct(void* fct)
 
 // Builder
 #define GO(A)   \
-static uintptr_t my_builderconnect_fct_##A = 0;   \
-static void my_builderconnect_##A(void* builder, void* object, void* signal, void* handler, void* connect, int flags, void* data)     \
-{                                       \
-    RunFunction(my_context, my_builderconnect_fct_##A, 7, builder, object, signal, handler, connect, flags, data);\
+static uintptr_t my_builderconnect_fct_##A = 0;                                                                                     \
+static void my_builderconnect_##A(void* builder, void* object, void* signal, void* handler, void* connect, int flags, void* data)   \
+{                                                                                                                                   \
+    RunFunctionFmt(my_context, my_builderconnect_fct_##A, "pppppip", builder, object, signal, handler, connect, flags, data);       \
 }
 SUPER()
 #undef GO
@@ -357,10 +357,10 @@ static void* findBuilderConnectFct(void* fct)
 
 // GtkCellLayoutDataFunc
 #define GO(A)   \
-static uintptr_t my_GtkCellLayoutDataFunc_fct_##A = 0;                                                  \
-static void my_GtkCellLayoutDataFunc_##A(void* layout, void* cell, void* tree, void* iter, void* data)  \
-{                                       \
-    RunFunction(my_context, my_GtkCellLayoutDataFunc_fct_##A, 5, layout, cell, tree, iter, data);\
+static uintptr_t my_GtkCellLayoutDataFunc_fct_##A = 0;                                                      \
+static void my_GtkCellLayoutDataFunc_##A(void* layout, void* cell, void* tree, void* iter, void* data)      \
+{                                                                                                           \
+    RunFunctionFmt(my_context, my_GtkCellLayoutDataFunc_fct_##A, "ppppp", layout, cell, tree, iter, data);  \
 }
 SUPER()
 #undef GO
@@ -380,10 +380,10 @@ static void* findGtkCellLayoutDataFuncFct(void* fct)
 
 // GtkTreeCellDataFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeCellDataFunc_fct_##A = 0;                                                  \
-static void my_GtkTreeCellDataFunc_##A(void* column, void* cell, void* tree, void* iter, void* data)  \
-{                                       \
-    RunFunction(my_context, my_GtkTreeCellDataFunc_fct_##A, 5, column, cell, tree, iter, data);\
+static uintptr_t my_GtkTreeCellDataFunc_fct_##A = 0;                                                        \
+static void my_GtkTreeCellDataFunc_##A(void* column, void* cell, void* tree, void* iter, void* data)        \
+{                                                                                                           \
+    RunFunctionFmt(my_context, my_GtkTreeCellDataFunc_fct_##A, "ppppp", column, cell, tree, iter, data);    \
 }
 SUPER()
 #undef GO
@@ -404,10 +404,10 @@ static void* findGtkTreeCellDataFuncFct(void* fct)
 
 // GDestroyNotify
 #define GO(A)   \
-static uintptr_t my_GDestroyNotify_fct_##A = 0;                     \
-static void my_GDestroyNotify_##A(void* data)                       \
-{                                                                   \
-    RunFunction(my_context, my_GDestroyNotify_fct_##A, 1, data);    \
+static uintptr_t my_GDestroyNotify_fct_##A = 0;                         \
+static void my_GDestroyNotify_##A(void* data)                           \
+{                                                                       \
+    RunFunctionFmt(my_context, my_GDestroyNotify_fct_##A, "p", data);   \
 }
 SUPER()
 #undef GO
@@ -427,10 +427,10 @@ static void* findGDestroyNotifyFct(void* fct)
 
 // GtkTreeModelForeachFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeModelForeachFunc_fct_##A = 0;                                                    \
-static int my_GtkTreeModelForeachFunc_##A(void* model, void* path, void* iter, void* data)                  \
-{                                                                                                           \
-    return (int)RunFunction(my_context, my_GtkTreeModelForeachFunc_fct_##A, 4, model, path, iter, data);    \
+static uintptr_t my_GtkTreeModelForeachFunc_fct_##A = 0;                                                            \
+static int my_GtkTreeModelForeachFunc_##A(void* model, void* path, void* iter, void* data)                          \
+{                                                                                                                   \
+    return (int)RunFunctionFmt(my_context, my_GtkTreeModelForeachFunc_fct_##A, "pppp", model, path, iter, data);    \
 }
 SUPER()
 #undef GO
@@ -450,10 +450,10 @@ static void* findGtkTreeModelForeachFuncFct(void* fct)
 
 // GtkTreeSelectionSelectedForeachFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeSelectionSelectedForeachFunc_fct_##A = 0;                                                    \
-static int my_GtkTreeSelectionSelectedForeachFunc_##A(void* selection, void* path, void* iter, void* data)                  \
-{                                                                                                           \
-    return (int)RunFunction(my_context, my_GtkTreeSelectionSelectedForeachFunc_fct_##A, 4, selection, path, iter, data);    \
+static uintptr_t my_GtkTreeSelectionSelectedForeachFunc_fct_##A = 0;                                                                \
+static int my_GtkTreeSelectionSelectedForeachFunc_##A(void* selection, void* path, void* iter, void* data)                          \
+{                                                                                                                                   \
+    return (int)RunFunctionFmt(my_context, my_GtkTreeSelectionSelectedForeachFunc_fct_##A, "pppp", selection, path, iter, data);    \
 }
 SUPER()
 #undef GO
@@ -473,10 +473,10 @@ static void* findGtkTreeSelectionSelectedForeachFuncFct(void* fct)
 
 // GtkClipboardReceivedFunc
 #define GO(A)   \
-static uintptr_t my_GtkClipboardReceivedFunc_fct_##A = 0;                                   \
-static void my_GtkClipboardReceivedFunc_##A(void* clipboard, void* sel, void* data)        \
-{                                                                                               \
-    RunFunction(my_context, my_GtkClipboardReceivedFunc_fct_##A, 3, clipboard, sel, data); \
+static uintptr_t my_GtkClipboardReceivedFunc_fct_##A = 0;                                           \
+static void my_GtkClipboardReceivedFunc_##A(void* clipboard, void* sel, void* data)                 \
+{                                                                                                   \
+    RunFunctionFmt(my_context, my_GtkClipboardReceivedFunc_fct_##A, "ppp", clipboard, sel, data);   \
 }
 SUPER()
 #undef GO
@@ -496,10 +496,10 @@ static void* findGtkClipboardReceivedFuncFct(void* fct)
 
 // GtkClipboardTextReceivedFunc
 #define GO(A)   \
-static uintptr_t my_GtkClipboardTextReceivedFunc_fct_##A = 0;                                   \
-static void my_GtkClipboardTextReceivedFunc_##A(void* clipboard, void* text, void* data)        \
-{                                                                                               \
-    RunFunction(my_context, my_GtkClipboardTextReceivedFunc_fct_##A, 3, clipboard, text, data); \
+static uintptr_t my_GtkClipboardTextReceivedFunc_fct_##A = 0;                                           \
+static void my_GtkClipboardTextReceivedFunc_##A(void* clipboard, void* text, void* data)                \
+{                                                                                                       \
+    RunFunctionFmt(my_context, my_GtkClipboardTextReceivedFunc_fct_##A, "ppp", clipboard, text, data);  \
 }
 SUPER()
 #undef GO
@@ -519,10 +519,10 @@ static void* findGtkClipboardTextReceivedFuncFct(void* fct)
 
 // GtkTreeViewSearchEqualFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeViewSearchEqualFunc_fct_##A = 0;                                                     \
-static int my_GtkTreeViewSearchEqualFunc_##A(void* model, int column, void* key, void* iter, void* data)        \
-{                                                                                                               \
-    return RunFunction(my_context, my_GtkTreeViewSearchEqualFunc_fct_##A, 5, model, column, key, iter, data);   \
+static uintptr_t my_GtkTreeViewSearchEqualFunc_fct_##A = 0;                                                             \
+static int my_GtkTreeViewSearchEqualFunc_##A(void* model, int column, void* key, void* iter, void* data)                \
+{                                                                                                                       \
+    return RunFunctionFmt(my_context, my_GtkTreeViewSearchEqualFunc_fct_##A, "pippp", model, column, key, iter, data);  \
 }
 SUPER()
 #undef GO
@@ -542,10 +542,10 @@ static void* findGtkTreeViewSearchEqualFuncFct(void* fct)
 
 // GtkTreeIterCompareFunc
 #define GO(A)   \
-static uintptr_t my_GtkTreeIterCompareFunc_fct_##A = 0;                                         \
-static int my_GtkTreeIterCompareFunc_##A(void* model, void* a, void* b, void* data)             \
-{                                                                                               \
-    return RunFunction(my_context, my_GtkTreeIterCompareFunc_fct_##A, 4, model, a, b, data);    \
+static uintptr_t my_GtkTreeIterCompareFunc_fct_##A = 0;                                                 \
+static int my_GtkTreeIterCompareFunc_##A(void* model, void* a, void* b, void* data)                     \
+{                                                                                                       \
+    return RunFunctionFmt(my_context, my_GtkTreeIterCompareFunc_fct_##A, "pppp", model, a, b, data);    \
 }
 SUPER()
 #undef GO
@@ -565,10 +565,10 @@ static void* findGtkTreeIterCompareFuncFct(void* fct)
 
 // GdkInputFunction
 #define GO(A)   \
-static uintptr_t my_GdkInputFunction_fct_##A = 0;                                  \
-static void my_GdkInputFunction_##A(void* data, int source, int cond)              \
-{                                                                                   \
-    RunFunction(my_context, my_GdkInputFunction_fct_##A, 3, data, source, cond);   \
+static uintptr_t my_GdkInputFunction_fct_##A = 0;                                       \
+static void my_GdkInputFunction_##A(void* data, int source, int cond)                   \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_GdkInputFunction_fct_##A, "pii", data, source, cond); \
 }
 SUPER()
 #undef GO
@@ -588,10 +588,10 @@ static void* findGdkInputFunctionFct(void* fct)
 
 // GtkCallbackMarshal
 #define GO(A)   \
-static uintptr_t my_GtkCallbackMarshal_fct_##A = 0;                                 \
-static void my_GtkCallbackMarshal_##A(void* obj, void* data, uint32_t n, void* args)\
-{                                                                                   \
-    RunFunction(my_context, my_GtkCallbackMarshal_fct_##A, 4, obj, data, n, args);  \
+static uintptr_t my_GtkCallbackMarshal_fct_##A = 0;                                         \
+static void my_GtkCallbackMarshal_##A(void* obj, void* data, uint32_t n, void* args)        \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_GtkCallbackMarshal_fct_##A, "ppup", obj, data, n, args);  \
 }
 SUPER()
 #undef GO
@@ -610,10 +610,10 @@ static void* findGtkCallbackMarshalFct(void* fct)
 }
 // GtkPrinterFunc ...
 #define GO(A)   \
-static uintptr_t my_GtkPrinterFunc_fct_##A = 0;                         \
-static int my_GtkPrinterFunc_##A(void* a, void* b)                      \
-{                                                                       \
-    return (int)RunFunction(my_context, my_GtkPrinterFunc_fct_##A, 2, a, b); \
+static uintptr_t my_GtkPrinterFunc_fct_##A = 0;                                     \
+static int my_GtkPrinterFunc_##A(void* a, void* b)                                  \
+{                                                                                   \
+    return (int)RunFunctionFmt(my_context, my_GtkPrinterFunc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -632,10 +632,10 @@ static void* find_GtkPrinterFunc_Fct(void* fct)
 }
 // GtkFileFilterFunc ...
 #define GO(A)   \
-static uintptr_t my_GtkFileFilterFunc_fct_##A = 0;                              \
-static int my_GtkFileFilterFunc_##A(void* a, void* b)                           \
-{                                                                               \
-    return (int)RunFunction(my_context, my_GtkFileFilterFunc_fct_##A, 2, a, b); \
+static uintptr_t my_GtkFileFilterFunc_fct_##A = 0;                                      \
+static int my_GtkFileFilterFunc_##A(void* a, void* b)                                   \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_GtkFileFilterFunc_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -654,10 +654,10 @@ static void* find_GtkFileFilterFunc_Fct(void* fct)
 }
 // GtkPrintJobCompleteFunc ...
 #define GO(A)   \
-static uintptr_t my_GtkPrintJobCompleteFunc_fct_##A = 0;                        \
-static void my_GtkPrintJobCompleteFunc_##A(void* a, void* b, void* c)           \
-{                                                                               \
-    RunFunction(my_context, my_GtkPrintJobCompleteFunc_fct_##A, 3, a, b, c);    \
+static uintptr_t my_GtkPrintJobCompleteFunc_fct_##A = 0;                            \
+static void my_GtkPrintJobCompleteFunc_##A(void* a, void* b, void* c)               \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_GtkPrintJobCompleteFunc_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -677,10 +677,10 @@ static void* find_GtkPrintJobCompleteFunc_Fct(void* fct)
 
 // GtkLinkButtonUri ...
 #define GO(A)   \
-static uintptr_t my_GtkLinkButtonUri_fct_##A = 0;                       \
-static void my_GtkLinkButtonUri_##A(void* a, void* b, void* c)          \
-{                                                                       \
-    RunFunction(my_context, my_GtkLinkButtonUri_fct_##A, 3, a, b, c);   \
+static uintptr_t my_GtkLinkButtonUri_fct_##A = 0;                               \
+static void my_GtkLinkButtonUri_##A(void* a, void* b, void* c)                  \
+{                                                                               \
+    RunFunctionFmt(my_context, my_GtkLinkButtonUri_fct_##A, "ppp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -833,7 +833,7 @@ EXPORT int my_gtk_clipboard_set_with_owner(x64emu_t* emu, void* clipboard, void*
 
 static void* my_translate_func(void* path, my_signal_t* sig)
 {
-    return (void*)RunFunction(my_context, sig->c_handler, 2, path, sig->data);
+    return (void*)RunFunctionFmt(my_context, sig->c_handler, "pp", path, sig->data);
 }
 
 EXPORT void my_gtk_stock_set_translate_func(x64emu_t* emu, void* domain, void* f, void* data, void* notify)
diff --git a/src/wrapped/wrappedkrb5.c b/src/wrapped/wrappedkrb5.c
index 26419814..f703e549 100755
--- a/src/wrapped/wrappedkrb5.c
+++ b/src/wrapped/wrappedkrb5.c
@@ -34,10 +34,10 @@ GO(4)
 
 // krb5_prompter ...
 #define GO(A)   \
-static uintptr_t my_krb5_prompter_fct_##A = 0;                                      \
-static int my_krb5_prompter_##A(void* a, void* b, void* c, void* d, int e, void* f) \
-{                                                                                   \
-    return RunFunction(my_context, my_krb5_prompter_fct_##A, 6, a, b, c, d, e, f);  \
+static uintptr_t my_krb5_prompter_fct_##A = 0;                                                  \
+static int my_krb5_prompter_##A(void* a, void* b, void* c, void* d, int e, void* f)             \
+{                                                                                               \
+    return RunFunctionFmt(my_context, my_krb5_prompter_fct_##A, "ppppip", a, b, c, d, e, f);    \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedldapr.c b/src/wrapped/wrappedldapr.c
index 7b5087e4..3db8b0a8 100755
--- a/src/wrapped/wrappedldapr.c
+++ b/src/wrapped/wrappedldapr.c
@@ -41,10 +41,10 @@ GO(4)
 
 // LDAP_SASL_INTERACT_PROC ...
 #define GO(A)   \
-static uintptr_t my_LDAP_SASL_INTERACT_PROC_fct_##A = 0;                                \
-static int my_LDAP_SASL_INTERACT_PROC_##A(void* a, unsigned b, void* c, void* d)        \
-{                                                                                       \
-    return RunFunction(my_context, my_LDAP_SASL_INTERACT_PROC_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_LDAP_SASL_INTERACT_PROC_fct_##A = 0;                                        \
+static int my_LDAP_SASL_INTERACT_PROC_##A(void* a, unsigned b, void* c, void* d)                \
+{                                                                                               \
+    return RunFunctionFmt(my_context, my_LDAP_SASL_INTERACT_PROC_fct_##A, "pupp", a, b, c, d);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibasound.c b/src/wrapped/wrappedlibasound.c
index b28a36ba..74910772 100755
--- a/src/wrapped/wrappedlibasound.c
+++ b/src/wrapped/wrappedlibasound.c
@@ -47,10 +47,10 @@ GO(3)
 
 // snd_async_callback_t
 #define GO(A)   \
-static uintptr_t my_async_fct_##A = 0;   \
-static void* my_async_##A(void* handler)     \
-{                                       \
-    return (void*)RunFunction(my_context, my_async_fct_##A, 1, handler);\
+static uintptr_t my_async_fct_##A = 0;                                          \
+static void* my_async_##A(void* handler)                                        \
+{                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_async_fct_##A, "p", handler);   \
 }
 SUPER()
 #undef GO
@@ -69,10 +69,10 @@ static void* findAsyncFct(void* fct)
 }
 // snd_mixer_elem_callback_t
 #define GO(A)   \
-static uintptr_t my_elem_fct_##A = 0;   \
-static int my_elem_##A(void* elem, uint32_t mask)                       \
-{                                                                       \
-    return (int)RunFunction(my_context, my_elem_fct_##A, 2, elem, mask);\
+static uintptr_t my_elem_fct_##A = 0;                                           \
+static int my_elem_##A(void* elem, uint32_t mask)                               \
+{                                                                               \
+    return (int)RunFunctionFmt(my_context, my_elem_fct_##A, "pu", elem, mask);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibc.c b/src/wrapped/wrappedlibc.c
index 3f4e7a09..cb4ae59d 100755
--- a/src/wrapped/wrappedlibc.c
+++ b/src/wrapped/wrappedlibc.c
@@ -24,7 +24,7 @@
 #include <poll.h>
 #include <sys/epoll.h>
 #include <ftw.h>
-#include <sys/syscall.h> 
+#include <sys/syscall.h>
 #include <sys/socket.h>
 #include <sys/utsname.h>
 #include <sys/mman.h>
@@ -131,10 +131,10 @@ GO(15)
 
 // compare
 #define GO(A)   \
-static uintptr_t my_compare_fct_##A = 0;        \
-static int my_compare_##A(void* a, void* b)     \
-{                                               \
-    return (int)RunFunction(my_context, my_compare_fct_##A, 2, a, b);\
+static uintptr_t my_compare_fct_##A = 0;                                    \
+static int my_compare_##A(void* a, void* b)                                 \
+{                                                                           \
+    return (int)RunFunctionFmt(my_context, my_compare_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -160,7 +160,7 @@ static int my_ftw64_##A(void* fpath, void* sb, int flag)    \
 {                                                           \
     struct x64_stat64 x64st;                                \
     UnalignStat64(sb, &x64st);                              \
-    return (int)RunFunction(my_context, my_ftw64_fct_##A, 3, fpath, &x64st, flag);  \
+    return (int)RunFunctionFmt(my_context, my_ftw64_fct_##A, "ppi", fpath, &x64st, flag);   \
 }
 SUPER()
 #undef GO
@@ -182,9 +182,9 @@ static void* findftw64Fct(void* fct)
 static uintptr_t my_nftw64_fct_##A = 0;                                     \
 static int my_nftw64_##A(void* fpath, void* sb, int flag, void* ftwbuff)    \
 {                                                                           \
-    struct x64_stat64 x64st;                                              \
-    UnalignStat64(sb, &x64st);                                             \
-    return (int)RunFunction(my_context, my_nftw64_fct_##A, 4, fpath, &x64st, flag, ftwbuff);   \
+    struct x64_stat64 x64st;                                                \
+    UnalignStat64(sb, &x64st);                                              \
+    return (int)RunFunctionFmt(my_context, my_nftw64_fct_##A, "ppip", fpath, &x64st, flag, ftwbuff);    \
 }
 SUPER()
 #undef GO
@@ -202,10 +202,10 @@ static void* findnftw64Fct(void* fct)
 }
 // globerr
 #define GO(A)   \
-static uintptr_t my_globerr_fct_##A = 0;                                        \
-static int my_globerr_##A(void* epath, int eerrno)                              \
-{                                                                               \
-    return (int)RunFunction(my_context, my_globerr_fct_##A, 2, epath, eerrno);  \
+static uintptr_t my_globerr_fct_##A = 0;                                                \
+static int my_globerr_##A(void* epath, int eerrno)                                      \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_globerr_fct_##A, "pi", epath, eerrno);    \
 }
 SUPER()
 #undef GO
@@ -225,10 +225,10 @@ static void* findgloberrFct(void* fct)
 }
 // free
 #define GO(A)   \
-static uintptr_t my_free_fct_##A = 0;               \
-static void my_free_##A(void* p)                    \
-{                                                   \
-    RunFunction(my_context, my_free_fct_##A, 1, p); \
+static uintptr_t my_free_fct_##A = 0;                       \
+static void my_free_##A(void* p)                            \
+{                                                           \
+    RunFunctionFmt(my_context, my_free_fct_##A, "p", p);    \
 }
 SUPER()
 #undef GO
@@ -251,10 +251,10 @@ static void* findfreeFct(void* fct)
 #undef dirent
 // filter_dir
 #define GO(A)   \
-static uintptr_t my_filter_dir_fct_##A = 0;                               \
-static int my_filter_dir_##A(const struct dirent* a)                    \
-{                                                                       \
-    return (int)RunFunction(my_context, my_filter_dir_fct_##A, 1, a);     \
+static uintptr_t my_filter_dir_fct_##A = 0;                                 \
+static int my_filter_dir_##A(const struct dirent* a)                        \
+{                                                                           \
+    return (int)RunFunctionFmt(my_context, my_filter_dir_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -274,10 +274,10 @@ static void* findfilter_dirFct(void* fct)
 }
 // compare_dir
 #define GO(A)   \
-static uintptr_t my_compare_dir_fct_##A = 0;                                  \
-static int my_compare_dir_##A(const struct dirent* a, const struct dirent* b)    \
-{                                                                           \
-    return (int)RunFunction(my_context, my_compare_dir_fct_##A, 2, a, b);     \
+static uintptr_t my_compare_dir_fct_##A = 0;                                    \
+static int my_compare_dir_##A(const struct dirent* a, const struct dirent* b)   \
+{                                                                               \
+    return (int)RunFunctionFmt(my_context, my_compare_dir_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -299,10 +299,10 @@ static void* findcompare_dirFct(void* fct)
 
 // filter64
 #define GO(A)   \
-static uintptr_t my_filter64_fct_##A = 0;                               \
-static int my_filter64_##A(const struct dirent64* a)                    \
-{                                                                       \
-    return (int)RunFunction(my_context, my_filter64_fct_##A, 1, a);     \
+static uintptr_t my_filter64_fct_##A = 0;                                   \
+static int my_filter64_##A(const struct dirent64* a)                        \
+{                                                                           \
+    return (int)RunFunctionFmt(my_context, my_filter64_fct_##A, "p", a);    \
 }
 SUPER()
 #undef GO
@@ -325,7 +325,7 @@ static void* findfilter64Fct(void* fct)
 static uintptr_t my_compare64_fct_##A = 0;                                      \
 static int my_compare64_##A(const struct dirent64* a, const struct dirent64* b) \
 {                                                                               \
-    return (int)RunFunction(my_context, my_compare64_fct_##A, 2, a, b);         \
+    return (int)RunFunctionFmt(my_context, my_compare64_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -345,10 +345,10 @@ static void* findcompare64Fct(void* fct)
 }
 // printf_output
 #define GO(A)   \
-static uintptr_t my_printf_output_fct_##A = 0;                                  \
-static int my_printf_output_##A(void* a, void* b, void* c)                      \
-{                                                                               \
-    return (int)RunFunction(my_context, my_printf_output_fct_##A, 3, a, b, c);  \
+static uintptr_t my_printf_output_fct_##A = 0;                                          \
+static int my_printf_output_##A(void* a, void* b, void* c)                              \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_printf_output_fct_##A, "ppp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -368,10 +368,10 @@ static void* findprintf_outputFct(void* fct)
 }
 // printf_arginfo
 #define GO(A)   \
-static uintptr_t my_printf_arginfo_fct_##A = 0;                                     \
-static int my_printf_arginfo_##A(void* a, size_t b, void* c, void* d)               \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_printf_arginfo_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_printf_arginfo_fct_##A = 0;                                             \
+static int my_printf_arginfo_##A(void* a, size_t b, void* c, void* d)                       \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_printf_arginfo_fct_##A, "pLpp", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -391,10 +391,10 @@ static void* findprintf_arginfoFct(void* fct)
 }
 // printf_type
 #define GO(A)   \
-static uintptr_t my_printf_type_fct_##A = 0;                   \
-static void my_printf_type_##A(void* a, va_list* b)            \
-{                                                              \
-    RunFunction(my_context, my_printf_type_fct_##A, 2, a, b);  \
+static uintptr_t my_printf_type_fct_##A = 0;                        \
+static void my_printf_type_##A(void* a, va_list* b)                 \
+{                                                                   \
+    RunFunctionFmt(my_context, my_printf_type_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -416,8 +416,8 @@ static void* findprintf_typeFct(void* fct)
 #undef SUPER
 
 // some my_XXX declare and defines
-int32_t my___libc_start_main(x64emu_t* emu, int *(main) (int, char * *, char * *), 
-    int argc, char * * ubp_av, void (*init) (void), void (*fini) (void), 
+int32_t my___libc_start_main(x64emu_t* emu, int *(main) (int, char * *, char * *),
+    int argc, char * * ubp_av, void (*init) (void), void (*fini) (void),
     void (*rtld_fini) (void), void (* stack_end)); // implemented in x64run_private.c
 EXPORT void my___libc_init_first(x64emu_t* emu, int argc, char* arg0, char** b)
 {
@@ -494,7 +494,7 @@ pid_t EXPORT my_fork(x64emu_t* emu)
     if(v<0) {
         printf_log(LOG_NONE, "BOX64: Warning, fork errored... (%d)\n", v);
         // error...
-    } else if(v>0) {  
+    } else if(v>0) {
         // execute atforks parent functions
         for (int i=0; i<my_context->atfork_sz; --i)
             if(my_context->atforks[i].parent)
@@ -1649,7 +1649,7 @@ EXPORT int32_t my___open(x64emu_t* emu, void* pathname, int32_t flags, uint32_t
 //            unprotectDB((uintptr_t)p, count-ret, 1);
 //            int l;
 //            do {
-//                l = read(fd, p, count-ret); 
+//                l = read(fd, p, count-ret);
 //                if(l>0) {
 //                    p+=l; ret+=l;
 //                }
@@ -1877,7 +1877,7 @@ EXPORT int32_t my_execv(x64emu_t* emu, const char* path, char* const argv[])
         newargv[0] = x86?emu->context->box86path:emu->context->box64path;
         if(script) newargv[1] = emu->context->bashpath; // script needs to be launched with bash
         memcpy(newargv+toadd, argv+skip_first, sizeof(char*)*(n+toadd));
-        if(self) 
+        if(self)
             newargv[1] = emu->context->fullpath;
         else {
             // TODO check if envp is not environ and add the value on a copy
@@ -2053,7 +2053,7 @@ EXPORT int32_t my_execvp(x64emu_t* emu, const char* path, char* const argv[])
         // uname -m is redirected to box64 -m
         path = my_context->box64path;
         char *argv2[3] = { my_context->box64path, argv[1], NULL };
-        
+
         return execvp(path, argv2);
     }
 
@@ -2124,7 +2124,7 @@ EXPORT int32_t my_execlp(x64emu_t* emu, const char* path)
     return ret;
 }
 
-EXPORT int32_t my_posix_spawn(x64emu_t* emu, pid_t* pid, const char* fullpath, 
+EXPORT int32_t my_posix_spawn(x64emu_t* emu, pid_t* pid, const char* fullpath,
     const posix_spawn_file_actions_t *actions, const posix_spawnattr_t* attrp,  char* const argv[], char* const envp[])
 {
     int self = isProcSelf(fullpath, "exe");
@@ -2157,13 +2157,13 @@ EXPORT int32_t my_posix_spawn(x64emu_t* emu, pid_t* pid, const char* fullpath,
         ret = posix_spawn(pid, newargv[0], actions, attrp, (char* const*)newargv, envp);
         printf_log(/*LOG_DEBUG*/LOG_INFO, "posix_spawn returned %d\n", ret);
         //box_free(newargv);
-    } else 
+    } else
         ret = posix_spawn(pid, fullpath, actions, attrp, argv, envp);
     return ret;
 }
 
 // execvp should use PATH to search for the program first
-EXPORT int32_t my_posix_spawnp(x64emu_t* emu, pid_t* pid, const char* path, 
+EXPORT int32_t my_posix_spawnp(x64emu_t* emu, pid_t* pid, const char* path,
     const posix_spawn_file_actions_t *actions, const posix_spawnattr_t* attrp,  char* const argv[], char* const envp[])
 {
     // need to use BOX64_PATH / PATH here...
@@ -2232,7 +2232,7 @@ EXPORT int32_t my___register_atfork(x64emu_t *emu, void* prepare, void* parent,
 EXPORT uint64_t my___umoddi3(uint64_t a, uint64_t b)
 {
     return a%b;
-}  
+}
 EXPORT uint64_t my___udivdi3(uint64_t a, uint64_t b)
 {
     return a/b;
@@ -2297,8 +2297,8 @@ EXPORT int32_t my_fcntl(x64emu_t* emu, int32_t a, int32_t b, void* c)
     int ret = fcntl(a, b, c);
     if(b==F_GETFL && ret!=-1)
         ret = of_unconvert(ret);
-    
-    return ret;    
+
+    return ret;
 }
 EXPORT int32_t my___fcntl(x64emu_t* emu, int32_t a, int32_t b, void* c) __attribute__((alias("my_fcntl")));
 
@@ -2371,10 +2371,10 @@ void InitCpuModel()
     my___cpu_model.__cpu_vendor = VENDOR_INTEL;
     my___cpu_model.__cpu_type = INTEL_PENTIUM_M;
     my___cpu_model.__cpu_subtype = 0; // N/A
-    my___cpu_model.__cpu_features[0] = (1<<FEATURE_CMOV) 
-                                     | (1<<FEATURE_MMX) 
-                                     | (1<<FEATURE_SSE) 
-                                     | (1<<FEATURE_SSE2) 
+    my___cpu_model.__cpu_features[0] = (1<<FEATURE_CMOV)
+                                     | (1<<FEATURE_MMX)
+                                     | (1<<FEATURE_SSE)
+                                     | (1<<FEATURE_SSE2)
                                      | (1<<FEATURE_SSE3)
                                      | (1<<FEATURE_SSSE3)
                                      | (1<<FEATURE_MOVBE)
@@ -2514,7 +2514,7 @@ EXPORT int my_readlinkat(x64emu_t* emu, int fd, void* path, void* buf, size_t bu
 EXPORT void* my_mmap64(x64emu_t* emu, void *addr, unsigned long length, int prot, int flags, int fd, int64_t offset)
 {
     (void)emu;
-    if(prot&PROT_WRITE) 
+    if(prot&PROT_WRITE)
         prot|=PROT_READ;    // PROT_READ is implicit with PROT_WRITE on i386
     if(box64_log<LOG_DEBUG) {dynarec_log(LOG_DEBUG, "mmap64(%p, %lu, 0x%x, 0x%x, %d, %ld) => ", addr, length, prot, flags, fd, offset);}
     #ifndef NOALIGN
@@ -2530,7 +2530,7 @@ EXPORT void* my_mmap64(x64emu_t* emu, void *addr, unsigned long length, int prot
     #endif
     void* ret = mmap64(addr, length, prot, flags, fd, offset);
     #ifndef NOALIGN
-    if((ret!=(void*)-1) && (flags&0x40) && 
+    if((ret!=(void*)-1) && (flags&0x40) &&
       (((uintptr_t)ret>0xffffffffLL) || (box64_wine && ((uintptr_t)ret&0xffff)))) {
         printf_log(LOG_DEBUG, "Warning, mmap on 32bits didn't worked, ask %p, got %p ", addr, ret);
         munmap(ret, length);
@@ -2640,7 +2640,7 @@ EXPORT int my_mprotect(x64emu_t* emu, void *addr, unsigned long len, int prot)
 {
     (void)emu;
     dynarec_log(LOG_DEBUG, "mprotect(%p, %lu, 0x%x)\n", addr, len, prot);
-    if(prot&PROT_WRITE) 
+    if(prot&PROT_WRITE)
         prot|=PROT_READ;    // PROT_READ is implicit with PROT_WRITE on x86_64
     int ret = mprotect(addr, len, prot);
     #ifdef DYNAREC
@@ -2705,24 +2705,24 @@ typedef struct my_cookie_s {
 static ssize_t my_cookie_read(void *p, char *buf, size_t size)
 {
     my_cookie_t* cookie = (my_cookie_t*)p;
-    return (ssize_t)RunFunction(my_context, cookie->r, 3, cookie->cookie, buf, size);
+    return (ssize_t)RunFunctionFmt(my_context, cookie->r, "ppL", cookie->cookie, buf, size);
 }
 static ssize_t my_cookie_write(void *p, const char *buf, size_t size)
 {
     my_cookie_t* cookie = (my_cookie_t*)p;
-    return (ssize_t)RunFunction(my_context, cookie->w, 3, cookie->cookie, buf, size);
+    return (ssize_t)RunFunctionFmt(my_context, cookie->w, "ppL", cookie->cookie, buf, size);
 }
 static int my_cookie_seek(void *p, off64_t *offset, int whence)
 {
     my_cookie_t* cookie = (my_cookie_t*)p;
-    return RunFunction(my_context, cookie->s, 3, cookie->cookie, offset, whence);
+    return RunFunctionFmt(my_context, cookie->s, "ppi", cookie->cookie, offset, whence);
 }
 static int my_cookie_close(void *p)
 {
     my_cookie_t* cookie = (my_cookie_t*)p;
     int ret = 0;
     if(cookie->c)
-        ret = RunFunction(my_context, cookie->c, 1, cookie->cookie);
+        ret = RunFunctionFmt(my_context, cookie->c, "p", cookie->cookie);
     box_free(cookie);
     return ret;
 }
@@ -2994,7 +2994,7 @@ EXPORT int my_backtrace_ip(x64emu_t* emu, void** buffer, int size)
                         unwind->regs[7] += 8;
                         buffer[idx] = (void*)ret_addr;
                         success = 2;
-                    } else 
+                    } else
                         break;
                 }
             } else
@@ -3041,7 +3041,7 @@ EXPORT void my_backtrace_symbols_fd(x64emu_t* emu, uintptr_t* buffer, int size,
         if(!sz) sz=0x100;   // arbitrary value...
         if(symbname && buffer[i]>=start && (buffer[i]<(start+sz) || !sz))
             snprintf(s, 200, "%s+%ld [%p]\n", symbname, buffer[i] - start, (void*)buffer[i]);
-        else 
+        else
             snprintf(s, 200, "??? [%p]\n", (void*)buffer[i]);
         int dummy = write(fd, s, strlen(s));
         (void)dummy;
diff --git a/src/wrapped/wrappedlibcups.c b/src/wrapped/wrappedlibcups.c
index 23541940..478b5c06 100755
--- a/src/wrapped/wrappedlibcups.c
+++ b/src/wrapped/wrappedlibcups.c
@@ -36,10 +36,10 @@ GO(4)
 
 // cups_dest_cb_t ...
 #define GO(A)   \
-static uintptr_t my_cups_dest_cb_t_fct_##A = 0;                                 \
-static int my_cups_dest_cb_t_##A(void* a, uint32_t b, void* c)                  \
-{                                                                               \
-    return (int)RunFunction(my_context, my_cups_dest_cb_t_fct_##A, 3, a, b, c); \
+static uintptr_t my_cups_dest_cb_t_fct_##A = 0;                                         \
+static int my_cups_dest_cb_t_##A(void* a, uint32_t b, void* c)                          \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_cups_dest_cb_t_fct_##A, "pup", a, b, c);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibfuse.c b/src/wrapped/wrappedlibfuse.c
index ee75fa3d..b02468da 100755
--- a/src/wrapped/wrappedlibfuse.c
+++ b/src/wrapped/wrappedlibfuse.c
@@ -140,10 +140,10 @@ GO(3)
 
 // fuse_opt_proc
 #define GO(A)   \
-static uintptr_t my_fuse_opt_proc_fct_##A = 0;                                      \
-static int my_fuse_opt_proc_##A(void* a, void* b, int c, void* d)                   \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_fuse_opt_proc_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_fuse_opt_proc_fct_##A = 0;                                              \
+static int my_fuse_opt_proc_##A(void* a, void* b, int c, void* d)                           \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_fuse_opt_proc_fct_##A, "ppip", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -163,11 +163,11 @@ static void* findfuse_opt_procFct(void* fct)
 
 // init
 #define GO(A)   \
-static uintptr_t my_init_fct_##A = 0;                 \
-static void my_init_##A(void* a, void* b)             \
-{                                                     \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "init");               \
-    RunFunction(my_context, my_init_fct_##A, 2, a, b);\
+static uintptr_t my_init_fct_##A = 0;                           \
+static void my_init_##A(void* a, void* b)                       \
+{                                                               \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "init");           \
+    RunFunctionFmt(my_context, my_init_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -187,11 +187,11 @@ static void* find_init_Fct(void* fct)
 
 // destroy
 #define GO(A)   \
-static uintptr_t my_destroy_fct_##A = 0;                \
-static void my_destroy_##A(void* a)                     \
-{                                                       \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "destroy");                \
-    RunFunction(my_context, my_destroy_fct_##A, 1, a);  \
+static uintptr_t my_destroy_fct_##A = 0;                    \
+static void my_destroy_##A(void* a)                         \
+{                                                           \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "destroy");    \
+    RunFunctionFmt(my_context, my_destroy_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -215,7 +215,7 @@ static uintptr_t my_lookup_fct_##A = 0;
 static void my_lookup_##A(void* a, unsigned long b, const char* c)              \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s(%p, %lu, %s)\n", "lookup", a, b, c);   \
-    RunFunction(my_context, my_lookup_fct_##A, 3, a, b, c);                     \
+    RunFunctionFmt(my_context, my_lookup_fct_##A, "pLp", a, b, c);              \
 }
 SUPER()
 #undef GO
@@ -235,11 +235,11 @@ static void* find_lookup_Fct(void* fct)
 
 // forget
 #define GO(A)   \
-static uintptr_t my_forget_fct_##A = 0;                     \
-static void my_forget_##A(void* a, unsigned long b, unsigned long c)\
-{                                                           \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "forget");             \
-    RunFunction(my_context, my_forget_fct_##A, 3, a, b, c); \
+static uintptr_t my_forget_fct_##A = 0;                                 \
+static void my_forget_##A(void* a, unsigned long b, unsigned long c)    \
+{                                                                       \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "forget");                 \
+    RunFunctionFmt(my_context, my_forget_fct_##A, "pLL", a, b, c);      \
 }
 SUPER()
 #undef GO
@@ -259,11 +259,11 @@ static void* find_forget_Fct(void* fct)
 
 // getattr
 #define GO(A)   \
-static uintptr_t my_getattr_fct_##A = 0;                        \
-static void my_getattr_##A(void* a, unsigned long b, void* c)   \
-{                                                               \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "getattr");        \
-    RunFunction(my_context, my_getattr_fct_##A, 3, a, b, c);    \
+static uintptr_t my_getattr_fct_##A = 0;                            \
+static void my_getattr_##A(void* a, unsigned long b, void* c)       \
+{                                                                   \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "getattr");            \
+    RunFunctionFmt(my_context, my_getattr_fct_##A, "pLp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -283,13 +283,13 @@ static void* find_getattr_Fct(void* fct)
 
 // setattr
 #define GO(A)   \
-static uintptr_t my_setattr_fct_##A = 0;                        \
-static void my_setattr_##A(void* a, unsigned long b, struct stat* c, int d, void* e)   \
-{                                                               \
-    struct stat c_;                                             \
-    AlignStat64(c, &c_);                                        \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "setattr");        \
-    RunFunction(my_context, my_setattr_fct_##A, 5, a, b, &c_, d, e);    \
+static uintptr_t my_setattr_fct_##A = 0;                                            \
+static void my_setattr_##A(void* a, unsigned long b, struct stat* c, int d, void* e)\
+{                                                                                   \
+    struct stat c_;                                                                 \
+    AlignStat64(c, &c_);                                                            \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "setattr");                            \
+    RunFunctionFmt(my_context, my_setattr_fct_##A, "pLpip", a, b, &c_, d, e);       \
 }
 SUPER()
 #undef GO
@@ -309,11 +309,11 @@ static void* find_setattr_Fct(void* fct)
 
 // readlink
 #define GO(A)   \
-static uintptr_t my_readlink_fct_##A = 0;                   \
-static void my_readlink_##A(void* a, unsigned long b)       \
-{                                                           \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "readlink");               \
-    RunFunction(my_context, my_readlink_fct_##A, 2, a, b);  \
+static uintptr_t my_readlink_fct_##A = 0;                           \
+static void my_readlink_##A(void* a, unsigned long b)               \
+{                                                                   \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "readlink");           \
+    RunFunctionFmt(my_context, my_readlink_fct_##A, "pL", a, b);    \
 }
 SUPER()
 #undef GO
@@ -336,8 +336,8 @@ static void* find_readlink_Fct(void* fct)
 static uintptr_t my_mknod_fct_##A = 0;                                                  \
 static void my_mknod_##A(void* a, unsigned long b, const char* c, mode_t d, dev_t e)    \
 {                                                                                       \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "mknod");              \
-    RunFunction(my_context, my_mknod_fct_##A, 5, a, b, c, of_convert(d), e);            \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "mknod");                                  \
+    RunFunctionFmt(my_context, my_mknod_fct_##A, "pLpuL", a, b, c, of_convert(d), e);   \
 }
 SUPER()
 #undef GO
@@ -357,11 +357,11 @@ static void* find_mknod_Fct(void* fct)
 
 // mkdir
 #define GO(A)   \
-static uintptr_t my_mkdir_fct_##A = 0;                                      \
-static void my_mkdir_##A(void* a, unsigned long b, const char* c, mode_t d) \
-{                                                                           \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "mkdir");              \
-    RunFunction(my_context, my_mkdir_fct_##A, 4, a, b, c, of_convert(d));   \
+static uintptr_t my_mkdir_fct_##A = 0;                                              \
+static void my_mkdir_##A(void* a, unsigned long b, const char* c, mode_t d)         \
+{                                                                                   \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "mkdir");                              \
+    RunFunctionFmt(my_context, my_mkdir_fct_##A, "pLpu", a, b, c, of_convert(d));   \
 }
 SUPER()
 #undef GO
@@ -385,7 +385,7 @@ static uintptr_t my_unlink_fct_##A = 0;                             \
 static void my_unlink_##A(void* a, unsigned long b, const char* c)  \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "unlink");             \
-    RunFunction(my_context, my_unlink_fct_##A, 3, a, b, c);         \
+    RunFunctionFmt(my_context, my_unlink_fct_##A, "pLp", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -405,11 +405,11 @@ static void* find_unlink_Fct(void* fct)
 
 // rmdir
 #define GO(A)   \
-static uintptr_t my_rmdir_fct_##A = 0;                             \
-static void my_rmdir_##A(void* a, unsigned long b, const char* c)  \
+static uintptr_t my_rmdir_fct_##A = 0;                              \
+static void my_rmdir_##A(void* a, unsigned long b, const char* c)   \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "rmdir");              \
-    RunFunction(my_context, my_rmdir_fct_##A, 3, a, b, c);         \
+    RunFunctionFmt(my_context, my_rmdir_fct_##A, "pLp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -429,11 +429,11 @@ static void* find_rmdir_Fct(void* fct)
 
 // symlink
 #define GO(A)   \
-static uintptr_t my_symlink_fct_##A = 0;                                            \
+static uintptr_t my_symlink_fct_##A = 0;                                \
 static void my_symlink_##A(void* a, const char* b, unsigned long c, const char* d)  \
-{                                                                                   \
+{                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "symlink");                \
-    RunFunction(my_context, my_symlink_fct_##A, 4, a, b, c, d);                     \
+    RunFunctionFmt(my_context, my_symlink_fct_##A, "ppLp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -453,11 +453,11 @@ static void* find_symlink_Fct(void* fct)
 
 // rename
 #define GO(A)   \
-static uintptr_t my_rename_fct_##A = 0;                                                             \
+static uintptr_t my_rename_fct_##A = 0;                                     \
 static void my_rename_##A(void* a, unsigned long b, const char* c, unsigned long d, const char* e)  \
-{                                                                                                   \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "rename");             \
-    RunFunction(my_context, my_rename_fct_##A, 5, a, b, c, d, e);                                   \
+{                                                                           \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "rename");                     \
+    RunFunctionFmt(my_context, my_rename_fct_##A, "pLpLp", a, b, c, d, e);  \
 }
 SUPER()
 #undef GO
@@ -477,11 +477,11 @@ static void* find_rename_Fct(void* fct)
 
 // link
 #define GO(A)   \
-static uintptr_t my_link_fct_##A = 0;                                               \
+static uintptr_t my_link_fct_##A = 0;                                   \
 static void my_link_##A(void* a, unsigned long b, unsigned long c, const char* d)   \
-{                                                                                   \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "link");               \
-    RunFunction(my_context, my_link_fct_##A, 4, a, b, c, d);                        \
+{                                                                       \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "link");                   \
+    RunFunctionFmt(my_context, my_link_fct_##A, "pLLp", a, b, c, d);    \
 }
 SUPER()
 #undef GO
@@ -501,11 +501,11 @@ static void* find_link_Fct(void* fct)
 
 // open
 #define GO(A)   \
-static uintptr_t my_open_fct_##A = 0;                           \
-static void my_open_##A(void* a, unsigned long b, const char* c)\
-{                                                               \
+static uintptr_t my_open_fct_##A = 0;                               \
+static void my_open_##A(void* a, unsigned long b, const char* c)    \
+{                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "open");               \
-    RunFunction(my_context, my_open_fct_##A, 3, a, b, c);       \
+    RunFunctionFmt(my_context, my_open_fct_##A, "pLp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -525,11 +525,11 @@ static void* find_open_Fct(void* fct)
 
 // read
 #define GO(A)   \
-static uintptr_t my_read_fct_##A = 0;                                                           \
+static uintptr_t my_read_fct_##A = 0;                                           \
 static void my_read_##A(void* a, unsigned long b, const char* c, size_t d, off_t e, void* f)    \
-{                                                                                               \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "read");               \
-    RunFunction(my_context, my_read_fct_##A, 6, a, b, c, d, e, f);                              \
+{                                                                               \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "read");                           \
+    RunFunctionFmt(my_context, my_read_fct_##A, "pLpLlp", a, b, c, d, e, f);    \
 }
 SUPER()
 #undef GO
@@ -549,11 +549,11 @@ static void* find_read_Fct(void* fct)
 
 // write
 #define GO(A)   \
-static uintptr_t my_write_fct_##A = 0;                                                          \
+static uintptr_t my_write_fct_##A = 0;                                          \
 static void my_write_##A(void* a, unsigned long b, const char* c, size_t d, off_t e, void* f)   \
-{                                                                                               \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "write");              \
-    RunFunction(my_context, my_write_fct_##A, 6, a, b, c, d, e, f);                             \
+{                                                                               \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "write");                          \
+    RunFunctionFmt(my_context, my_write_fct_##A, "pLpLlp", a, b, c, d, e, f);   \
 }
 SUPER()
 #undef GO
@@ -577,7 +577,7 @@ static uintptr_t my_flush_fct_##A = 0;                              \
 static void my_flush_##A(void* a, unsigned long b, const char* c)   \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "flush");              \
-    RunFunction(my_context, my_flush_fct_##A, 3, a, b, c);          \
+    RunFunctionFmt(my_context, my_flush_fct_##A, "pLp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -597,11 +597,11 @@ static void* find_flush_Fct(void* fct)
 
 // release
 #define GO(A)   \
-static uintptr_t my_release_fct_##A = 0;                              \
-static void my_release_##A(void* a, unsigned long b, const char* c)   \
+static uintptr_t my_release_fct_##A = 0;                            \
+static void my_release_##A(void* a, unsigned long b, const char* c) \
 {                                                                   \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "release");                \
-    RunFunction(my_context, my_release_fct_##A, 3, a, b, c);          \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "release");            \
+    RunFunctionFmt(my_context, my_release_fct_##A, "pLp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -621,11 +621,11 @@ static void* find_release_Fct(void* fct)
 
 // fsync
 #define GO(A)   \
-static uintptr_t my_fsync_fct_##A = 0;                              \
-static void my_fsync_##A(void* a, unsigned long b, int c, void* d)  \
-{                                                                   \
-    printf_log(LOG_DEBUG, "fuse: call %s\n", "fsync");              \
-    RunFunction(my_context, my_fsync_fct_##A, 4, a, b, c, d);       \
+static uintptr_t my_fsync_fct_##A = 0;                                  \
+static void my_fsync_##A(void* a, unsigned long b, int c, void* d)      \
+{                                                                       \
+    printf_log(LOG_DEBUG, "fuse: call %s\n", "fsync");                  \
+    RunFunctionFmt(my_context, my_fsync_fct_##A, "pLip", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -649,7 +649,7 @@ static uintptr_t my_opendir_fct_##A = 0;
 static void my_opendir_##A(void* a, unsigned long b, void* c)                   \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s(%p, %lu, %p)\n", "opendir", a, b, c);  \
-    RunFunction(my_context, my_opendir_fct_##A, 3, a, b, c);                    \
+    RunFunctionFmt(my_context, my_opendir_fct_##A, "pLp", a, b, c);                    \
 }
 SUPER()
 #undef GO
@@ -673,7 +673,7 @@ static uintptr_t my_readdir_fct_##A = 0;
 static void my_readdir_##A(void* a, unsigned long b, size_t c, off_t d, void* e)    \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "readdir");                \
-    RunFunction(my_context, my_readdir_fct_##A, 5, a, b, c, d, e);                  \
+    RunFunctionFmt(my_context, my_readdir_fct_##A, "pLLlp", a, b, c, d, e);                  \
 }
 SUPER()
 #undef GO
@@ -697,7 +697,7 @@ static uintptr_t my_releasedir_fct_##A = 0;
 static void my_releasedir_##A(void* a, unsigned long b, void* c)                    \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s(%p, %lu, %p)\n", "releasedir", a, b, c);   \
-    RunFunction(my_context, my_releasedir_fct_##A, 3, a, b, c);                     \
+    RunFunctionFmt(my_context, my_releasedir_fct_##A, "pLp", a, b, c);                     \
 }
 SUPER()
 #undef GO
@@ -721,7 +721,7 @@ static uintptr_t my_fsyncdir_fct_##A = 0;                               \
 static void my_fsyncdir_##A(void* a, unsigned long b, int c, void* d)   \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fsyncdir");               \
-    RunFunction(my_context, my_fsyncdir_fct_##A, 4, a, b, c, d);        \
+    RunFunctionFmt(my_context, my_fsyncdir_fct_##A, "pLip", a, b, c, d);        \
 }
 SUPER()
 #undef GO
@@ -745,7 +745,7 @@ static uintptr_t my_statfs_fct_##A = 0;                     \
 static void my_statfs_##A(void* a, unsigned long b)         \
 {                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "statfs");             \
-    RunFunction(my_context, my_statfs_fct_##A, 2, a, b);    \
+    RunFunctionFmt(my_context, my_statfs_fct_##A, "pL", a, b);    \
 }
 SUPER()
 #undef GO
@@ -769,7 +769,7 @@ static uintptr_t my_setxattr_fct_##A = 0;
 static void my_setxattr_##A(void* a, unsigned long b, const char* c, const char* d, size_t e, int f)    \
 {                                                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "setxattr");               \
-    RunFunction(my_context, my_setxattr_fct_##A, 6, a, b, c, d, e, f);                                  \
+    RunFunctionFmt(my_context, my_setxattr_fct_##A, "pLppLi", a, b, c, d, e, f);                                  \
 }
 SUPER()
 #undef GO
@@ -793,7 +793,7 @@ static uintptr_t my_getxattr_fct_##A = 0;
 static void my_getxattr_##A(void* a, unsigned long b, const char* c, const char* d, size_t e)   \
 {                                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "getxattr");               \
-    RunFunction(my_context, my_getxattr_fct_##A, 5, a, b, c, d, e);                             \
+    RunFunctionFmt(my_context, my_getxattr_fct_##A, "pLppL", a, b, c, d, e);                             \
 }
 SUPER()
 #undef GO
@@ -817,7 +817,7 @@ static uintptr_t my_listxattr_fct_##A = 0;                      \
 static void my_listxattr_##A(void* a, unsigned long b, size_t c)\
 {                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "listxattr");              \
-    RunFunction(my_context, my_listxattr_fct_##A, 3, a, b, c);  \
+    RunFunctionFmt(my_context, my_listxattr_fct_##A, "pLL", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -841,7 +841,7 @@ static uintptr_t my_removexattr_fct_##A = 0;                            \
 static void my_removexattr_##A(void* a, unsigned long b, const char* c) \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "removexattr");                \
-    RunFunction(my_context, my_removexattr_fct_##A, 3, a, b, c);        \
+    RunFunctionFmt(my_context, my_removexattr_fct_##A, "pLp", a, b, c);        \
 }
 SUPER()
 #undef GO
@@ -865,7 +865,7 @@ static uintptr_t my_access_fct_##A = 0;                     \
 static void my_access_##A(void* a, unsigned long b, int c)  \
 {                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "access");             \
-    RunFunction(my_context, my_access_fct_##A, 3, a, b, c); \
+    RunFunctionFmt(my_context, my_access_fct_##A, "pLi", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -889,7 +889,7 @@ static uintptr_t my_create_fct_##A = 0;
 static void my_create_##A(void* a, unsigned long b, const char* c, mode_t d, void* e)   \
 {                                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "create");             \
-    RunFunction(my_context, my_create_fct_##A, 5, a, b, c, of_convert(d), e);           \
+    RunFunctionFmt(my_context, my_create_fct_##A, "pLpup", a, b, c, of_convert(d), e);           \
 }
 SUPER()
 #undef GO
@@ -913,7 +913,7 @@ static uintptr_t my_getlk_fct_##A = 0;                              \
 static void my_getlk_##A(void* a, unsigned long b, void* c, void* d)\
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "getlk");              \
-    RunFunction(my_context, my_getlk_fct_##A, 4, a, b, c, d);       \
+    RunFunctionFmt(my_context, my_getlk_fct_##A, "pLpp", a, b, c, d);       \
 }
 SUPER()
 #undef GO
@@ -937,7 +937,7 @@ static uintptr_t my_setlk_fct_##A = 0;                                      \
 static void my_setlk_##A(void* a, unsigned long b, void* c, void* d, int e) \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "setlk");              \
-    RunFunction(my_context, my_setlk_fct_##A, 5, a, b, c, d, e);            \
+    RunFunctionFmt(my_context, my_setlk_fct_##A, "pLppi", a, b, c, d, e);            \
 }
 SUPER()
 #undef GO
@@ -961,7 +961,7 @@ static uintptr_t my_bmap_fct_##A = 0;                                   \
 static void my_bmap_##A(void* a, unsigned long b, size_t c, uint64_t d) \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "bmap");               \
-    RunFunction(my_context, my_bmap_fct_##A, 4, a, b, c, d);            \
+    RunFunctionFmt(my_context, my_bmap_fct_##A, "pLLU", a, b, c, d);            \
 }
 SUPER()
 #undef GO
@@ -985,7 +985,7 @@ static uintptr_t my_ioctl_fct_##A = 0;
 static void my_ioctl_##A(void* a, unsigned long b, int c, void* d, void* e, unsigned f, void* g, size_t h, size_t i)\
 {                                                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "ioctl");                                                              \
-    RunFunction(my_context, my_ioctl_fct_##A, 9, a, b, c, d, e, f, g, h, i);                                        \
+    RunFunctionFmt(my_context, my_ioctl_fct_##A, "pLippupLL", a, b, c, d, e, f, g, h, i);                                        \
 }
 SUPER()
 #undef GO
@@ -1009,7 +1009,7 @@ static uintptr_t my_poll_fct_##A = 0;                                  \
 static void my_poll_##A(void* a, unsigned long b, void* c, void* d)    \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "poll");                  \
-    RunFunction(my_context, my_poll_fct_##A, 4, a, b, c, d);           \
+    RunFunctionFmt(my_context, my_poll_fct_##A, "pLpp", a, b, c, d);           \
 }
 SUPER()
 #undef GO
@@ -1033,7 +1033,7 @@ static uintptr_t my_write_buf_fct_##A = 0;
 static void my_write_buf_##A(void* a, unsigned long b, void* c, off_t d, void* e)   \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "write_buf");                          \
-    RunFunction(my_context, my_write_buf_fct_##A, 5, a, b, c, d, e);                \
+    RunFunctionFmt(my_context, my_write_buf_fct_##A, "pLplp", a, b, c, d, e);                \
 }
 SUPER()
 #undef GO
@@ -1057,7 +1057,7 @@ static uintptr_t my_retrieve_reply_fct_##A = 0;
 static void my_retrieve_reply_##A(void* a, void* b, unsigned long c, off_t d, void* e)  \
 {                                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "retrieve_reply");                         \
-    RunFunction(my_context, my_retrieve_reply_fct_##A, 5, a, b, c, d, e);               \
+    RunFunctionFmt(my_context, my_retrieve_reply_fct_##A, "ppLlp", a, b, c, d, e);               \
 }
 SUPER()
 #undef GO
@@ -1081,7 +1081,7 @@ static uintptr_t my_forget_multi_fct_##A = 0;                       \
 static void my_forget_multi_##A(void* a, size_t b, void* c)         \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "forget_multi");       \
-    RunFunction(my_context, my_forget_multi_fct_##A, 3, a, b, c);   \
+    RunFunctionFmt(my_context, my_forget_multi_fct_##A, "pLp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1105,7 +1105,7 @@ static uintptr_t my_flock_fct_##A = 0;                              \
 static void my_flock_##A(void* a, unsigned long b, void* c, int d)  \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "flock");              \
-    RunFunction(my_context, my_flock_fct_##A, 4, a, b, c, d);       \
+    RunFunctionFmt(my_context, my_flock_fct_##A, "pLpi", a, b, c, d);       \
 }
 SUPER()
 #undef GO
@@ -1129,7 +1129,7 @@ static uintptr_t my_fallocate_fct_##A = 0;
 static void my_fallocate_##A(void* a, unsigned long b, int c, off_t d, off_t e, void* f)    \
 {                                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fallocate");                                  \
-    RunFunction(my_context, my_fallocate_fct_##A, 6, a, b, c, d, e, f);                     \
+    RunFunctionFmt(my_context, my_fallocate_fct_##A, "pLillp", a, b, c, d, e, f);                     \
 }
 SUPER()
 #undef GO
@@ -1155,7 +1155,7 @@ static int my_getattr_op_##A(const char * a, struct stat * b)
     printf_log(LOG_DEBUG, "fuse: call %s\n", "getattr_op");                         \
     struct x64_stat64 b_;                                                           \
     UnalignStat64(b, &b_);                                                          \
-    int ret = (int)RunFunction(my_context, my_getattr_op_fct_##A, 2, a, &b_);       \
+    int ret = (int)RunFunctionFmt(my_context, my_getattr_op_fct_##A, "pp", a, &b_);       \
     AlignStat64(&b_, b);                                                            \
     return ret;                                                                     \
 }
@@ -1181,7 +1181,7 @@ static uintptr_t my_readlink_op_fct_##A = 0;                            \
 static int my_readlink_op_##A(const char * a, char * b, size_t c)       \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "readlink_op");            \
-    return (int)RunFunction(my_context, my_readlink_op_fct_##A, 3, a, b, c);\
+    return (int)RunFunctionFmt(my_context, my_readlink_op_fct_##A, "ppL", a, b, c);\
 }
 SUPER()
 #undef GO
@@ -1205,7 +1205,7 @@ static uintptr_t my_getdir_op_fct_##A = 0;
 static int my_getdir_op_##A(const char * a, void* b, void* c)                                                                   \
 {                                                                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "getdir_op");                                                                      \
-    return (int)RunFunction(my_context, my_getdir_op_fct_##A, 3, a, b, AddCheckBridge(my_lib->w.bridge, iFppiU, c, 0, NULL));   \
+    return (int)RunFunctionFmt(my_context, my_getdir_op_fct_##A, "ppp", a, b, AddCheckBridge(my_lib->w.bridge, iFppiU, c, 0, NULL));   \
 }
 SUPER()
 #undef GO
@@ -1229,7 +1229,7 @@ static uintptr_t my_mknod_op_fct_##A = 0;                                   \
 static int my_mknod_op_##A(const char * a, mode_t b, dev_t c)               \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "mknod_op");                   \
-    return (int)RunFunction(my_context, my_mknod_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_mknod_op_fct_##A, "puU", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1253,7 +1253,7 @@ static uintptr_t my_mkdir_op_fct_##A = 0;                               \
 static int my_mkdir_op_##A(const char * a, mode_t b)                    \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "mkdir_op");               \
-    return (int)RunFunction(my_context, my_mkdir_op_fct_##A, 2, a, b);  \
+    return (int)RunFunctionFmt(my_context, my_mkdir_op_fct_##A, "pu", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1277,7 +1277,7 @@ static uintptr_t my_unlink_op_fct_##A = 0;                              \
 static int my_unlink_op_##A(const char * a)                             \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "unlink_op");              \
-    return (int)RunFunction(my_context, my_unlink_op_fct_##A, 1, a);    \
+    return (int)RunFunctionFmt(my_context, my_unlink_op_fct_##A, "p", a);    \
 }
 SUPER()
 #undef GO
@@ -1301,7 +1301,7 @@ static uintptr_t my_rmdir_op_fct_##A = 0;                           \
 static int my_rmdir_op_##A(const char * a)                          \
 {                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "rmdir_op");           \
-    return (int)RunFunction(my_context, my_rmdir_op_fct_##A, 1, a); \
+    return (int)RunFunctionFmt(my_context, my_rmdir_op_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -1325,7 +1325,7 @@ static uintptr_t my_symlink_op_fct_##A = 0;                                 \
 static int my_symlink_op_##A(const char * a, const char * b)                \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "symlink_op");                 \
-    return (int)RunFunction(my_context, my_symlink_op_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_symlink_op_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -1349,7 +1349,7 @@ static uintptr_t my_rename_op_fct_##A = 0;                              \
 static int my_rename_op_##A(const char * a, const char * b)             \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "rename_op");              \
-    return (int)RunFunction(my_context, my_rename_op_fct_##A, 2, a, b); \
+    return (int)RunFunctionFmt(my_context, my_rename_op_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -1373,7 +1373,7 @@ static uintptr_t my_link_op_fct_##A = 0;                                \
 static int my_link_op_##A(const char * a, const char * b)               \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "link_op");                \
-    return (int)RunFunction(my_context, my_link_op_fct_##A, 2, a, b);   \
+    return (int)RunFunctionFmt(my_context, my_link_op_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -1397,7 +1397,7 @@ static uintptr_t my_chmod_op_fct_##A = 0;                               \
 static int my_chmod_op_##A(const char * a, mode_t b)                    \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "chmod_op");               \
-    return (int)RunFunction(my_context, my_chmod_op_fct_##A, 2, a, b);  \
+    return (int)RunFunctionFmt(my_context, my_chmod_op_fct_##A, "pu", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1421,7 +1421,7 @@ static uintptr_t my_chown_op_fct_##A = 0;                                   \
 static int my_chown_op_##A(const char * a, uid_t b, gid_t c)                \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "chown_op");                   \
-    return (int)RunFunction(my_context, my_chown_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_chown_op_fct_##A, "puu", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1445,7 +1445,7 @@ static uintptr_t my_truncate_op_fct_##A = 0;                                \
 static int my_truncate_op_##A(const char * a, off_t b)                      \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "truncate_op");                \
-    return (int)RunFunction(my_context, my_truncate_op_fct_##A, 2, a, b);   \
+    return (int)RunFunctionFmt(my_context, my_truncate_op_fct_##A, "pl", a, b);   \
 }
 SUPER()
 #undef GO
@@ -1469,7 +1469,7 @@ static uintptr_t my_utime_op_fct_##A = 0;                               \
 static int my_utime_op_##A(const char * a, void* b)                     \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "utime_op");               \
-    return (int)RunFunction(my_context, my_utime_op_fct_##A, 2, a, b);  \
+    return (int)RunFunctionFmt(my_context, my_utime_op_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1493,7 +1493,7 @@ static uintptr_t my_open_op_fct_##A = 0;                                \
 static int my_open_op_##A(const char * a, void* b)                      \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "open_op");                \
-    return (int)RunFunction(my_context, my_open_op_fct_##A, 2, a, b);   \
+    return (int)RunFunctionFmt(my_context, my_open_op_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -1517,7 +1517,7 @@ static uintptr_t my_read_op_fct_##A = 0;
 static int my_read_op_##A(const char * a, char * b, size_t c, off_t d, void* e) \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "read_op");                        \
-    return (int)RunFunction(my_context, my_read_op_fct_##A, 5, a, b, c, d, e);  \
+    return (int)RunFunctionFmt(my_context, my_read_op_fct_##A, "ppLlp", a, b, c, d, e);  \
 }
 SUPER()
 #undef GO
@@ -1541,7 +1541,7 @@ static uintptr_t my_write_op_fct_##A = 0;
 static int my_write_op_##A(const char * a, const char * b, size_t c, off_t d, void* e)  \
 {                                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "write_op");                               \
-    return (int)RunFunction(my_context, my_write_op_fct_##A, 5, a, b, c, d, e);         \
+    return (int)RunFunctionFmt(my_context, my_write_op_fct_##A, "ppLlp", a, b, c, d, e);         \
 }
 SUPER()
 #undef GO
@@ -1565,7 +1565,7 @@ static uintptr_t my_statfs_op_fct_##A = 0;                              \
 static int my_statfs_op_##A(const char * a, void* b)         \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "statfs_op");              \
-    return (int)RunFunction(my_context, my_statfs_op_fct_##A, 2, a, b); \
+    return (int)RunFunctionFmt(my_context, my_statfs_op_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -1589,7 +1589,7 @@ static uintptr_t my_flush_op_fct_##A = 0;                               \
 static int my_flush_op_##A(const char * a, void* b)                     \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "flush_op");               \
-    return (int)RunFunction(my_context, my_flush_op_fct_##A, 2, a, b);  \
+    return (int)RunFunctionFmt(my_context, my_flush_op_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1613,7 +1613,7 @@ static uintptr_t my_release_op_fct_##A = 0;                                 \
 static int my_release_op_##A(const char * a, void* b)                       \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "release_op");                 \
-    return (int)RunFunction(my_context, my_release_op_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_release_op_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -1637,7 +1637,7 @@ static uintptr_t my_fsync_op_fct_##A = 0;                                   \
 static int my_fsync_op_##A(const char * a, int b, void* c)                  \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fsync_op");                   \
-    return (int)RunFunction(my_context, my_fsync_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_fsync_op_fct_##A, "pip", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1661,7 +1661,7 @@ static uintptr_t my_setxattr_op_fct_##A = 0;
 static int my_setxattr_op_##A(const char * a, const char * b, const char * c, size_t d, int e)  \
 {                                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "setxattr_op");                                    \
-    return (int)RunFunction(my_context, my_setxattr_op_fct_##A, 5, a, b, c, d, e);                  \
+    return (int)RunFunctionFmt(my_context, my_setxattr_op_fct_##A, "pppLi", a, b, c, d, e);                  \
 }
 SUPER()
 #undef GO
@@ -1685,7 +1685,7 @@ static uintptr_t my_getxattr_op_fct_##A = 0;
 static int my_getxattr_op_##A(const char * a, const char * b, char * c, size_t d)   \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "getxattr_op");                        \
-    return (int)RunFunction(my_context, my_getxattr_op_fct_##A, 4, a, b, c, d);     \
+    return (int)RunFunctionFmt(my_context, my_getxattr_op_fct_##A, "pppL", a, b, c, d);     \
 }
 SUPER()
 #undef GO
@@ -1709,7 +1709,7 @@ static uintptr_t my_listxattr_op_fct_##A = 0;
 static int my_listxattr_op_##A(const char * a, char * b, size_t c)              \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "listxattr_op");                   \
-    return (int)RunFunction(my_context, my_listxattr_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_listxattr_op_fct_##A, "ppL", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1733,7 +1733,7 @@ static uintptr_t my_removexattr_op_fct_##A = 0;
 static int my_removexattr_op_##A(const char * a, const char * b)                \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "removexattr_op");                 \
-    return (int)RunFunction(my_context, my_removexattr_op_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_removexattr_op_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -1757,7 +1757,7 @@ static uintptr_t my_opendir_op_fct_##A = 0;                                 \
 static int my_opendir_op_##A(const char * a, void* b)                       \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "opendir_op");                 \
-    return (int)RunFunction(my_context, my_opendir_op_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_opendir_op_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -1781,7 +1781,7 @@ static uintptr_t my_readdir_op_fct_##A = 0;
 static int my_readdir_op_##A(const char * a, void * b, fuse_fill_dir_t c, off_t d, void* e)                                             \
 {                                                                                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "readdir_op");                                                                             \
-    return (int)RunFunction(my_context, my_readdir_op_fct_##A, 5, a, b, AddCheckBridge(my_lib->w.bridge, iFpppUi, c, 0, NULL), d, e);   \
+    return (int)RunFunctionFmt(my_context, my_readdir_op_fct_##A, "ppplp", a, b, AddCheckBridge(my_lib->w.bridge, iFpppUi, c, 0, NULL), d, e);   \
 }
 SUPER()
 #undef GO
@@ -1805,7 +1805,7 @@ static uintptr_t my_releasedir_op_fct_##A = 0;                              \
 static int my_releasedir_op_##A(const char * a, void* b)                    \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "releasedir_op");              \
-    return (int)RunFunction(my_context, my_releasedir_op_fct_##A,2, a, b);  \
+    return (int)RunFunctionFmt(my_context, my_releasedir_op_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1829,7 +1829,7 @@ static uintptr_t my_fsyncdir_op_fct_##A = 0;                                \
 static int my_fsyncdir_op_##A(const char * a, int b, void* c)               \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fsyncdir_op");                \
-    return (int)RunFunction(my_context, my_fsyncdir_op_fct_##A, 3, a, b, c);\
+    return (int)RunFunctionFmt(my_context, my_fsyncdir_op_fct_##A, "pip", a, b, c);\
 }
 SUPER()
 #undef GO
@@ -1853,7 +1853,7 @@ static uintptr_t my_init_op_fct_##A = 0;                                \
 static void* my_init_op_##A(void* a)                                    \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "init_op");                \
-    return (void*)RunFunction(my_context, my_init_op_fct_##A, 1, a);    \
+    return (void*)RunFunctionFmt(my_context, my_init_op_fct_##A, "p", a);    \
 }
 SUPER()
 #undef GO
@@ -1877,7 +1877,7 @@ static uintptr_t my_destroy_op_fct_##A = 0;                 \
 static void my_destroy_op_##A(void * a)                     \
 {                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "destroy_op"); \
-    RunFunction(my_context, my_destroy_op_fct_##A, 1, a);   \
+    RunFunctionFmt(my_context, my_destroy_op_fct_##A, "p", a);   \
 }
 SUPER()
 #undef GO
@@ -1901,7 +1901,7 @@ static uintptr_t my_access_op_fct_##A = 0;                              \
 static int my_access_op_##A(const char * a, int b)                      \
 {                                                                       \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "access_op");              \
-    return (int)RunFunction(my_context, my_access_op_fct_##A, 2, a, b); \
+    return (int)RunFunctionFmt(my_context, my_access_op_fct_##A, "pi", a, b); \
 }
 SUPER()
 #undef GO
@@ -1925,7 +1925,7 @@ static uintptr_t my_create_op_fct_##A = 0;                                  \
 static int my_create_op_##A(const char * a, mode_t b, void* c)              \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "create_op");                  \
-    return (int)RunFunction(my_context, my_create_op_fct_##A, 3, a, b, c);  \
+    return (int)RunFunctionFmt(my_context, my_create_op_fct_##A, "pup", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -1949,7 +1949,7 @@ static uintptr_t my_ftruncate_op_fct_##A = 0;
 static int my_ftruncate_op_##A(const char * a, off_t b, void* c)                \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "ftruncate_op");                   \
-    return (int)RunFunction(my_context, my_ftruncate_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_ftruncate_op_fct_##A, "plp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1975,7 +1975,7 @@ static int my_fgetattr_op_##A(const char * a, struct stat* b, void* c)
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fgetattr_op");                        \
     struct x64_stat64 b_;                                                           \
     UnalignStat64(b, &b_);                                                          \
-    int ret = (int)RunFunction(my_context, my_fgetattr_op_fct_##A, 3, a, &b_, c);   \
+    int ret = (int)RunFunctionFmt(my_context, my_fgetattr_op_fct_##A, "ppp", a, &b_, c);   \
     AlignStat64(&b_, b);                                                            \
     return ret;                                                                     \
 }
@@ -2001,7 +2001,7 @@ static uintptr_t my_lock_op_fct_##A = 0;
 static int my_lock_op_##A(const char * a, void* b, int c, void* d)              \
 {                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "lock_op");                        \
-    return (int)RunFunction(my_context, my_lock_op_fct_##A, 4, a, b, c, d);     \
+    return (int)RunFunctionFmt(my_context, my_lock_op_fct_##A, "ppip", a, b, c, d);     \
 }
 SUPER()
 #undef GO
@@ -2025,7 +2025,7 @@ static uintptr_t my_utimens_op_fct_##A = 0;                                 \
 static int my_utimens_op_##A(const char * a, const struct timespec b[2])    \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "utimens_op");                 \
-    return (int)RunFunction(my_context, my_utimens_op_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_utimens_op_fct_##A, "pp", a, b);    \
 }
 SUPER()
 #undef GO
@@ -2049,7 +2049,7 @@ static uintptr_t my_bmap_op_fct_##A = 0;                                    \
 static int my_bmap_op_##A(const char * a, size_t b, uint64_t *c)            \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "bmap_op");                    \
-    return (int)RunFunction(my_context, my_bmap_op_fct_##A, 3, a, b, c);    \
+    return (int)RunFunctionFmt(my_context, my_bmap_op_fct_##A, "pLp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -2073,7 +2073,7 @@ static uintptr_t my_ioctl_op_fct_##A = 0;
 static int my_ioctl_op_##A(const char * a, int b, void* c, void* d, unsigned int e, void* f)    \
 {                                                                                               \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "ioctl_op");                                       \
-    return (int)RunFunction(my_context, my_ioctl_op_fct_##A, 6, a, b, c, d, e, f);              \
+    return (int)RunFunctionFmt(my_context, my_ioctl_op_fct_##A, "pippup", a, b, c, d, e, f);              \
 }
 SUPER()
 #undef GO
@@ -2097,7 +2097,7 @@ static uintptr_t my_poll_op_fct_##A = 0;                                    \
 static int my_poll_op_##A(const char * a, void* b, void* c, unsigned * d)   \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "poll_op");                    \
-    return (int)RunFunction(my_context, my_poll_op_fct_##A, 4, a, b, c, d); \
+    return (int)RunFunctionFmt(my_context, my_poll_op_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -2121,7 +2121,7 @@ static uintptr_t my_write_buf_op_fct_##A = 0;
 static int my_write_buf_op_##A(const char * a, void* b, off_t c, void* d)           \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "write_buf_op");                       \
-    return (int)RunFunction(my_context, my_write_buf_op_fct_##A, 4, a, b, c, d);    \
+    return (int)RunFunctionFmt(my_context, my_write_buf_op_fct_##A, "pplp", a, b, c, d);    \
 }
 SUPER()
 #undef GO
@@ -2145,7 +2145,7 @@ static uintptr_t my_read_buf_op_fct_##A = 0;
 static int my_read_buf_op_##A(const char * a, void* b, size_t c, off_t d, void* e)  \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "read_buf_op");                        \
-    return (int)RunFunction(my_context, my_read_buf_op_fct_##A, 5, a, b, c, d, e);  \
+    return (int)RunFunctionFmt(my_context, my_read_buf_op_fct_##A, "ppLlp", a, b, c, d, e);  \
 }
 SUPER()
 #undef GO
@@ -2169,7 +2169,7 @@ static uintptr_t my_flock_op_fct_##A = 0;                                   \
 static int my_flock_op_##A(const char * a, void* b, int c)                  \
 {                                                                           \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "flock_op");                   \
-    return (int)RunFunction(my_context, my_flock_op_fct_##A, 3, a, b, c);   \
+    return (int)RunFunctionFmt(my_context, my_flock_op_fct_##A, "ppi", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -2193,7 +2193,7 @@ static uintptr_t my_fallocate_op_fct_##A = 0;
 static int my_fallocate_op_##A(const char * a, int b, off_t c, off_t d, void* e)    \
 {                                                                                   \
     printf_log(LOG_DEBUG, "fuse: call %s\n", "fallocate_op");                       \
-    return (int)RunFunction(my_context, my_fallocate_op_fct_##A, 5, a, b, c, d, e); \
+    return (int)RunFunctionFmt(my_context, my_fallocate_op_fct_##A, "pillp", a, b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -2376,5 +2376,5 @@ box64_showsegv=1;
 
 #define CUSTOM_FINI             \
     freeMy();
-    
+
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibgl.c b/src/wrapped/wrappedlibgl.c
index f210a255..153190de 100755
--- a/src/wrapped/wrappedlibgl.c
+++ b/src/wrapped/wrappedlibgl.c
@@ -23,7 +23,7 @@ static library_t* my_lib = NULL;
 
 // FIXME: old wrapped* type of file, cannot use generated/wrappedlibgltypes.h
 
-EXPORT void* my_glXGetProcAddress(x64emu_t* emu, void* name) 
+EXPORT void* my_glXGetProcAddress(x64emu_t* emu, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
@@ -58,7 +58,7 @@ GO(4)
 static uintptr_t my_debug_callback_fct_##A = 0;                                                                         \
 static void my_debug_callback_##A(int32_t a, int32_t b, uint32_t c, int32_t d, int32_t e, const char* f, const void* g) \
 {                                                                                                                       \
-    RunFunction(my_context, my_debug_callback_fct_##A, 7, a, b, c, d, e, f, g);                                         \
+    RunFunctionFmt(my_context, my_debug_callback_fct_##A, "iiuiipp", a, b, c, d, e, f, g);                                         \
 }
 SUPER()
 #undef GO
@@ -80,7 +80,7 @@ static void* find_debug_callback_Fct(void* fct)
 static uintptr_t my_program_callback_fct_##A = 0;                   \
 static void my_program_callback_##A(int32_t a, void* b)             \
 {                                                                   \
-    RunFunction(my_context, my_program_callback_fct_##A, 2, a, b);  \
+    RunFunctionFmt(my_context, my_program_callback_fct_##A, "ip", a, b);  \
 }
 SUPER()
 #undef GO
@@ -359,7 +359,7 @@ void* getGLProcAddress(x64emu_t* emu, glprocaddress_t procaddr, const char* rnam
         }
         #undef GO
         #undef SUPER
-    } else 
+    } else
         symbol = procaddr(rname);
     if(!symbol) {
         printf_dlsym(LOG_DEBUG, "%p\n", NULL);
@@ -371,7 +371,7 @@ void* getGLProcAddress(x64emu_t* emu, glprocaddress_t procaddr, const char* rnam
         printf_dlsym(LOG_DEBUG, "%p\n", (void*)ret);
         return (void*)ret; // already bridged
     }
-    // get wrapper    
+    // get wrapper
     k = kh_get(symbolmap, wrappers->glwrappers, rname);
     if(k==kh_end(wrappers->glwrappers) && strstr(rname, "ARB")==NULL) {
         // try again, adding ARB at the end if not present
@@ -397,4 +397,4 @@ void* getGLProcAddress(x64emu_t* emu, glprocaddress_t procaddr, const char* rnam
     ret = AddBridge(emu->context->system, kh_value(wrappers->glwrappers, k), symbol, 0, constname);
     printf_dlsym(LOG_DEBUG, "%p\n", (void*)ret);
     return (void*)ret;
-}
\ No newline at end of file
+}
diff --git a/src/wrapped/wrappedlibglu.c b/src/wrapped/wrappedlibglu.c
index 57a2bb4e..839ef5d2 100755
--- a/src/wrapped/wrappedlibglu.c
+++ b/src/wrapped/wrappedlibglu.c
@@ -42,7 +42,7 @@ GO(9)   \
 static uintptr_t my_glu_callback_fct_##A = 0;                       \
 static void my_glu_callback_##A(void* a, void* b)                   \
 {                                                                   \
-    RunFunction(my_context, my_glu_callback_fct_##A, 2, a, b);  \
+    RunFunctionFmt(my_context, my_glu_callback_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -64,7 +64,7 @@ static void* findglu_callbackFct(void* fct)
 static uintptr_t my_glu_callback4_fct_##A = 0;                              \
 static void my_glu_callback4_##A(void* a, void* b, void* c, void* d)        \
 {                                                                           \
-    RunFunction(my_context, my_glu_callback4_fct_##A, 4, a, b, c, d);   \
+    RunFunctionFmt(my_context, my_glu_callback4_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -86,7 +86,7 @@ static void* findglu_callback4Fct(void* fct)
 static uintptr_t my_glu_callback5_fct_##A = 0;                                  \
 static void my_glu_callback5_##A(void* a, void* b, void* c, void* d, void* e)   \
 {                                                                               \
-    RunFunction(my_context, my_glu_callback5_fct_##A, 5, a, b, c, d, e);    \
+    RunFunctionFmt(my_context, my_glu_callback5_fct_##A, "ppppp", a, b, c, d, e);    \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibibus.c b/src/wrapped/wrappedlibibus.c
index 95ea0f81..2b99bdec 100644
--- a/src/wrapped/wrappedlibibus.c
+++ b/src/wrapped/wrappedlibibus.c
@@ -38,7 +38,7 @@ GO(3)
 static uintptr_t my_GAsyncReadyCallback_fct_##A = 0;   \
 static void my_GAsyncReadyCallback_##A(void* source, void* res, void* data)     \
 {                                       \
-    RunFunction(my_context, my_GAsyncReadyCallback_fct_##A, 3, source, res, data);\
+    RunFunctionFmt(my_context, my_GAsyncReadyCallback_fct_##A, "ppp", source, res, data);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibpcre.c b/src/wrapped/wrappedlibpcre.c
index 1175f7dd..88834ecf 100755
--- a/src/wrapped/wrappedlibpcre.c
+++ b/src/wrapped/wrappedlibpcre.c
@@ -20,7 +20,7 @@ typedef void  (*pcre_free_t)(void *);
 EXPORT uintptr_t my_pcre_free;
 
 void wrapped_pcre_free(void* p) {
-    RunFunction(my_context, my_pcre_free, 1, p);
+    RunFunctionFmt(my_context, my_pcre_free, "p", p);
 }
 EXPORT pcre_free_t pcre_free = wrapped_pcre_free;
 
diff --git a/src/wrapped/wrappedlibrt.c b/src/wrapped/wrappedlibrt.c
index 29fa375c..c8fde49e 100755
--- a/src/wrapped/wrappedlibrt.c
+++ b/src/wrapped/wrappedlibrt.c
@@ -40,7 +40,7 @@ GO(3)
 static uintptr_t my_sigev_notify_fct_##A = 0;   \
 static void my_sigev_notify_##A(void* sigval)    \
 {                                       \
-    RunFunction(my_context, my_sigev_notify_fct_##A, 1, sigval);\
+    RunFunctionFmt(my_context, my_sigev_notify_fct_##A, "p", sigval);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibsm.c b/src/wrapped/wrappedlibsm.c
index daf095b7..8c46d241 100755
--- a/src/wrapped/wrappedlibsm.c
+++ b/src/wrapped/wrappedlibsm.c
@@ -54,25 +54,25 @@ typedef struct my_SmcCallbacks_s {
 static uintptr_t my_save_yourself_fct = 0;
 static void my_save_yourself(void* smcConn, void* clientData, int saveType, int shutdown, int interactStyle, int fast)
 {
-    RunFunction(my_context, my_save_yourself_fct, 6, smcConn, clientData, saveType, shutdown, interactStyle, fast);
+    RunFunctionFmt(my_context, my_save_yourself_fct, "ppiiii", smcConn, clientData, saveType, shutdown, interactStyle, fast);
 }
 
 static uintptr_t my_die_fct = 0;
 static void my_die(void* smcConn, void* clientData)
 {
-    RunFunction(my_context, my_die_fct, 2, smcConn, clientData);
+    RunFunctionFmt(my_context, my_die_fct, "pp", smcConn, clientData);
 }
 
 static uintptr_t my_shutdown_cancelled_fct = 0;
 static void my_shutdown_cancelled(void* smcConn, void* clientData)
 {
-    RunFunction(my_context, my_shutdown_cancelled_fct, 2, smcConn, clientData);
+    RunFunctionFmt(my_context, my_shutdown_cancelled_fct, "pp", smcConn, clientData);
 }
 
 static uintptr_t my_save_complete_fct = 0;
 static void my_save_complete(void* smcConn, void* clientData)
 {
-    RunFunction(my_context, my_save_complete_fct, 2, smcConn, clientData);
+    RunFunctionFmt(my_context, my_save_complete_fct, "pp", smcConn, clientData);
 }
 
 
@@ -102,7 +102,7 @@ GO(4)
 static uintptr_t my_Request_fct_##A = 0;        \
 static void my_Request_##A(void* a, void* b)     \
 {                                               \
-    RunFunction(my_context, my_Request_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_Request_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibsndfile.c b/src/wrapped/wrappedlibsndfile.c
index 37660663..ac7ec35d 100755
--- a/src/wrapped/wrappedlibsndfile.c
+++ b/src/wrapped/wrappedlibsndfile.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_sf_vio_get_filelen_fct_##A = 0;                                 \
 static int64_t my_sf_vio_get_filelen_##A(void* a)                                   \
 {                                                                                   \
-    return (int64_t)RunFunction(my_context, my_sf_vio_get_filelen_fct_##A, 1, a);   \
+    return (int64_t)RunFunctionFmt(my_context, my_sf_vio_get_filelen_fct_##A, "p", a);   \
 }
 SUPER()
 #undef GO
@@ -60,7 +60,7 @@ static void* find_sf_vio_get_filelen_Fct(void* fct)
 static uintptr_t my_sf_vio_seek_fct_##A = 0;                                                        \
 static int64_t my_sf_vio_seek_##A(int64_t offset, int whence, void *user_data)                      \
 {                                                                                                   \
-    return (int64_t)RunFunction(my_context, my_sf_vio_seek_fct_##A, 3, offset, whence, user_data);  \
+    return (int64_t)RunFunctionFmt(my_context, my_sf_vio_seek_fct_##A, "Iip", offset, whence, user_data);  \
 }
 SUPER()
 #undef GO
@@ -82,7 +82,7 @@ static void* find_sf_vio_seek_Fct(void* fct)
 static uintptr_t my_sf_vio_read_fct_##A = 0;                                                    \
 static int64_t my_sf_vio_read_##A(void* ptr, int64_t count, void *user_data)                    \
 {                                                                                               \
-    return (int64_t)RunFunction(my_context, my_sf_vio_read_fct_##A, 3, ptr, count, user_data);  \
+    return (int64_t)RunFunctionFmt(my_context, my_sf_vio_read_fct_##A, "pIp", ptr, count, user_data);  \
 }
 SUPER()
 #undef GO
@@ -104,7 +104,7 @@ static void* find_sf_vio_read_Fct(void* fct)
 static uintptr_t my_sf_vio_write_fct_##A = 0;                                                   \
 static int64_t my_sf_vio_write_##A(const void* ptr, int64_t count, void *user_data)             \
 {                                                                                               \
-    return (int64_t)RunFunction(my_context, my_sf_vio_write_fct_##A, 3, ptr, count, user_data); \
+    return (int64_t)RunFunctionFmt(my_context, my_sf_vio_write_fct_##A, "pIp", ptr, count, user_data); \
 }
 SUPER()
 #undef GO
@@ -126,7 +126,7 @@ static void* find_sf_vio_write_Fct(void* fct)
 static uintptr_t my_sf_vio_tell_fct_##A = 0;                                \
 static int64_t my_sf_vio_tell_##A(void* a)                                  \
 {                                                                           \
-    return (int64_t)RunFunction(my_context, my_sf_vio_tell_fct_##A, 1, a);  \
+    return (int64_t)RunFunctionFmt(my_context, my_sf_vio_tell_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibssl.c b/src/wrapped/wrappedlibssl.c
index 14f28ae9..040e3f89 100755
--- a/src/wrapped/wrappedlibssl.c
+++ b/src/wrapped/wrappedlibssl.c
@@ -41,7 +41,7 @@ GO(4)
 static uintptr_t my_pem_passwd_cb_fct_##A = 0;                                                      \
 static int my_pem_passwd_cb_##A(void* buf, int size, int rwflag, void* password)                    \
 {                                                                                                   \
-    return (int)RunFunction(my_context, my_pem_passwd_cb_fct_##A, 4, buf, size, rwflag, password);  \
+    return (int)RunFunctionFmt(my_context, my_pem_passwd_cb_fct_##A, "piip", buf, size, rwflag, password);  \
 }
 SUPER()
 #undef GO
@@ -65,7 +65,7 @@ static void* find_pem_passwd_cb_Fct(void* fct)
 static uintptr_t my_anonymous_fct_##A = 0;                                      \
 static void* my_anonymous_##A(void* a, void* b, void* c, void *d)               \
 {                                                                               \
-    return (void*)RunFunction(my_context, my_anonymous_fct_##A, 4, a, b, c, d);   \
+    return (void*)RunFunctionFmt(my_context, my_anonymous_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -90,7 +90,7 @@ static void* find_anonymous_Fct(void* fct)
 static uintptr_t my_verify_fct_##A = 0;                                 \
 static int my_verify_##A(int a, void* b)                                \
 {                                                                       \
-    return (int)RunFunction(my_context, my_verify_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my_verify_fct_##A, "ip", a, b);    \
 }
 SUPER()
 #undef GO
@@ -124,7 +124,7 @@ static void* reverse_verify_Fct(void* fct)
 static uintptr_t my_ex_new_fct_##A = 0;                                                        \
 static void my_ex_new_##A(void* parent, void* ptr, void* ad, int idx, long argl, void* argp)   \
 {                                                                                           \
-    RunFunction(my_context, my_ex_new_fct_##A, 6, parent, ptr, ad, idx, argl, argp);           \
+    RunFunctionFmt(my_context, my_ex_new_fct_##A, "pppilp", parent, ptr, ad, idx, argl, argp);           \
 }
 SUPER()
 #undef GO
@@ -148,7 +148,7 @@ static void* find_ex_new_Fct(void* fct)
 static uintptr_t my_ex_free_fct_##A = 0;                                                        \
 static void my_ex_free_##A(void* parent, void* ptr, void* ad, int idx, long argl, void* argp)   \
 {                                                                                               \
-    RunFunction(my_context, my_ex_free_fct_##A, 6, parent, ptr, ad, idx, argl, argp);           \
+    RunFunctionFmt(my_context, my_ex_free_fct_##A, "pppilp", parent, ptr, ad, idx, argl, argp);           \
 }
 SUPER()
 #undef GO
@@ -172,7 +172,7 @@ static void* find_ex_free_Fct(void* fct)
 static uintptr_t my_ex_dup_fct_##A = 0;                                                             \
 static int my_ex_dup_##A(void* to, void* from, void* from_d, int idx, long argl, void* argp)        \
 {                                                                                                   \
-    return (int) RunFunction(my_context, my_ex_dup_fct_##A, 6, to, from, from_d, idx, argl, argp);  \
+    return (int) RunFunctionFmt(my_context, my_ex_dup_fct_##A, "pppilp", to, from, from_d, idx, argl, argp);  \
 }
 SUPER()
 #undef GO
@@ -196,7 +196,7 @@ static void* find_ex_dup_Fct(void* fct)
 static uintptr_t my_client_cb_fct_##A = 0;                                                                              \
 static uint32_t my_client_cb_##A(void* ssl, void* hint, void* identity, uint32_t id_len, void* psk, uint32_t psk_len)   \
 {                                                                                                                       \
-    return RunFunction(my_context, my_client_cb_fct_##A, 6, ssl, hint, identity, id_len, psk, psk_len);                 \
+    return RunFunctionFmt(my_context, my_client_cb_fct_##A, "pppupu", ssl, hint, identity, id_len, psk, psk_len);                 \
 }
 SUPER()
 #undef GO
@@ -220,7 +220,7 @@ static void* find_client_cb_Fct(void* fct)
 static uintptr_t my_proto_select_fct_##A = 0;                                                           \
 static int my_proto_select_##A(void* s, void* out, void* outlen, void* in, uint32_t inlen, void* arg)   \
 {                                                                                                       \
-    return (int)RunFunction(my_context, my_proto_select_fct_##A, 6, s, out, outlen, in, inlen, arg);    \
+    return (int)RunFunctionFmt(my_context, my_proto_select_fct_##A, "ppppup", s, out, outlen, in, inlen, arg);    \
 }
 SUPER()
 #undef GO
@@ -244,7 +244,7 @@ static void* find_proto_select_Fct(void* fct)
 static uintptr_t my_client_cert_fct_##A = 0;                                    \
 static int my_client_cert_##A(void* a, void* b, void* c)                        \
 {                                                                               \
-    return (int)RunFunction(my_context, my_client_cert_fct_##A, 3, a, b, c);    \
+    return (int)RunFunctionFmt(my_context, my_client_cert_fct_##A, "ppp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -268,7 +268,7 @@ static void* find_client_cert_Fct(void* fct)
 static uintptr_t my_alpn_select_fct_##A = 0;                                            \
 static int my_alpn_select_##A(void* a, void* b, void* c, void* d, uint32_t e, void* f)  \
 {                                                                                       \
-    return (int)RunFunction(my_context, my_alpn_select_fct_##A, 6, a, b, c, d, e, f);   \
+    return (int)RunFunctionFmt(my_context, my_alpn_select_fct_##A, "ppppup", a, b, c, d, e, f);   \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibssl3.c b/src/wrapped/wrappedlibssl3.c
index 88c758d9..9c287b56 100755
--- a/src/wrapped/wrappedlibssl3.c
+++ b/src/wrapped/wrappedlibssl3.c
@@ -37,7 +37,7 @@ GO(4)
 static uintptr_t my3_pem_passwd_cb_fct_##A = 0;                                                      \
 static int my3_pem_passwd_cb_##A(void* buf, int size, int rwflag, void* password)                    \
 {                                                                                                   \
-    return (int)RunFunction(my_context, my3_pem_passwd_cb_fct_##A, 4, buf, size, rwflag, password);  \
+    return (int)RunFunctionFmt(my_context, my3_pem_passwd_cb_fct_##A, "piip", buf, size, rwflag, password);  \
 }
 SUPER()
 #undef GO
@@ -61,7 +61,7 @@ static void* find_pem_passwd_cb_Fct(void* fct)
 static uintptr_t my3_anonymous_fct_##A = 0;                                      \
 static void* my3_anonymous_##A(void* a, void* b, void* c, void *d)               \
 {                                                                               \
-    return (void*)RunFunction(my_context, my3_anonymous_fct_##A, 4, a, b, c, d);   \
+    return (void*)RunFunctionFmt(my_context, my3_anonymous_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -86,7 +86,7 @@ static void* find_anonymous_Fct(void* fct)
 static uintptr_t my3_verify_fct_##A = 0;                                 \
 static int my3_verify_##A(int a, void* b)                                \
 {                                                                       \
-    return (int)RunFunction(my_context, my3_verify_fct_##A, 2, a, b);    \
+    return (int)RunFunctionFmt(my_context, my3_verify_fct_##A, "ip", a, b);    \
 }
 SUPER()
 #undef GO
@@ -120,7 +120,7 @@ static void* reverse_verify_Fct(void* fct)
 static uintptr_t my3_ex_new_fct_##A = 0;                                                        \
 static void my3_ex_new_##A(void* parent, void* ptr, void* ad, int idx, long argl, void* argp)   \
 {                                                                                           \
-    RunFunction(my_context, my3_ex_new_fct_##A, 6, parent, ptr, ad, idx, argl, argp);           \
+    RunFunctionFmt(my_context, my3_ex_new_fct_##A, "pppilp", parent, ptr, ad, idx, argl, argp);           \
 }
 SUPER()
 #undef GO
@@ -144,7 +144,7 @@ static void* find_ex_new_Fct(void* fct)
 static uintptr_t my3_ex_free_fct_##A = 0;                                                        \
 static void my3_ex_free_##A(void* parent, void* ptr, void* ad, int idx, long argl, void* argp)   \
 {                                                                                               \
-    RunFunction(my_context, my3_ex_free_fct_##A, 6, parent, ptr, ad, idx, argl, argp);           \
+    RunFunctionFmt(my_context, my3_ex_free_fct_##A, "pppilp", parent, ptr, ad, idx, argl, argp);           \
 }
 SUPER()
 #undef GO
@@ -168,7 +168,7 @@ static void* find_ex_free_Fct(void* fct)
 static uintptr_t my3_ex_dup_fct_##A = 0;                                                             \
 static int my3_ex_dup_##A(void* to, void* from, void* from_d, int idx, long argl, void* argp)        \
 {                                                                                                   \
-    return (int) RunFunction(my_context, my3_ex_dup_fct_##A, 6, to, from, from_d, idx, argl, argp);  \
+    return (int) RunFunctionFmt(my_context, my3_ex_dup_fct_##A, "pppilp", to, from, from_d, idx, argl, argp);  \
 }
 SUPER()
 #undef GO
@@ -192,7 +192,7 @@ static void* find_ex_dup_Fct(void* fct)
 static uintptr_t my3_client_cb_fct_##A = 0;                                                                              \
 static uint32_t my3_client_cb_##A(void* ssl, void* hint, void* identity, uint32_t id_len, void* psk, uint32_t psk_len)   \
 {                                                                                                                       \
-    return RunFunction(my_context, my3_client_cb_fct_##A, 6, ssl, hint, identity, id_len, psk, psk_len);                 \
+    return RunFunctionFmt(my_context, my3_client_cb_fct_##A, "pppupu", ssl, hint, identity, id_len, psk, psk_len);                 \
 }
 SUPER()
 #undef GO
@@ -216,7 +216,7 @@ static void* find_client_cb_Fct(void* fct)
 static uintptr_t my3_proto_select_fct_##A = 0;                                                           \
 static int my3_proto_select_##A(void* s, void* out, void* outlen, void* in, uint32_t inlen, void* arg)   \
 {                                                                                                       \
-    return (int)RunFunction(my_context, my3_proto_select_fct_##A, 6, s, out, outlen, in, inlen, arg);    \
+    return (int)RunFunctionFmt(my_context, my3_proto_select_fct_##A, "ppppup", s, out, outlen, in, inlen, arg);    \
 }
 SUPER()
 #undef GO
@@ -240,7 +240,7 @@ static void* find_proto_select_Fct(void* fct)
 static uintptr_t my3_client_cert_fct_##A = 0;                                    \
 static int my3_client_cert_##A(void* a, void* b, void* c)                        \
 {                                                                               \
-    return (int)RunFunction(my_context, my3_client_cert_fct_##A, 3, a, b, c);    \
+    return (int)RunFunctionFmt(my_context, my3_client_cert_fct_##A, "ppp", a, b, c);    \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibtinfo.c b/src/wrapped/wrappedlibtinfo.c
index 6e15e498..125a60bd 100755
--- a/src/wrapped/wrappedlibtinfo.c
+++ b/src/wrapped/wrappedlibtinfo.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_putc_fct_##A = 0;                           \
 static int my_putc_##A(char c)                                  \
 {                                                               \
-    return (int)RunFunction(my_context, my_putc_fct_##A, 1, c); \
+    return (int)RunFunctionFmt(my_context, my_putc_fct_##A, "c", c); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibtinfo6.c b/src/wrapped/wrappedlibtinfo6.c
index 9b1fc0ac..da4af0d2 100755
--- a/src/wrapped/wrappedlibtinfo6.c
+++ b/src/wrapped/wrappedlibtinfo6.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_putc_fct_##A = 0;                           \
 static int my_putc_##A(char c)                                  \
 {                                                               \
-    return (int)RunFunction(my_context, my_putc_fct_##A, 1, c); \
+    return (int)RunFunctionFmt(my_context, my_putc_fct_##A, "c", c); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibusb1.c b/src/wrapped/wrappedlibusb1.c
index e34f440f..38bef8ff 100755
--- a/src/wrapped/wrappedlibusb1.c
+++ b/src/wrapped/wrappedlibusb1.c
@@ -45,7 +45,7 @@ GO(9)   \
 static uintptr_t my_hotplug_fct_##A = 0;                                                    \
 static int my_hotplug_##A(void* ctx, void* device, int event, void* data)                   \
 {                                                                                           \
-    return (int)RunFunction(my_context, my_hotplug_fct_##A, 4, ctx, device, event, data);   \
+    return (int)RunFunctionFmt(my_context, my_hotplug_fct_##A, "ppip", ctx, device, event, data);   \
 }
 SUPER()
 #undef GO
@@ -67,7 +67,7 @@ static void* findhotplugFct(void* fct)
 static uintptr_t my_transfert_fct_##A = 0;                      \
 static void my_transfert_##A(void* ctx)                         \
 {                                                               \
-    RunFunction(my_context, my_transfert_fct_##A, 1, ctx);      \
+    RunFunctionFmt(my_context, my_transfert_fct_##A, "p", ctx);      \
 }
 SUPER()
 #undef GO
@@ -139,7 +139,7 @@ EXPORT int my_libusb_submit_transfer(x64emu_t* emu, my_libusb_transfer_t* t)
 {
     t->callback = findtransfertFct(t->callback);
     return my->libusb_submit_transfer(t); // don't put back callback, it's unknown if it's safe
-} 
+}
 
 EXPORT int my_libusb_cancel_transfer(x64emu_t* emu, my_libusb_transfer_t* t)
 {
diff --git a/src/wrapped/wrappedlibx11.c b/src/wrapped/wrappedlibx11.c
index afe26fd1..4b6a6463 100755
--- a/src/wrapped/wrappedlibx11.c
+++ b/src/wrapped/wrappedlibx11.c
@@ -109,14 +109,14 @@ GO(11)  \
 GO(12)  \
 GO(13)  \
 GO(14)  \
-GO(15)  
+GO(15)
 
 // wire_to_event
 #define GO(A)   \
 static uintptr_t my_wire_to_event_fct_##A = 0;                      \
 static int my_wire_to_event_##A(void* dpy, void* re, void* event)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_wire_to_event_fct_##A, 3, dpy, re, event);\
+    return (int)RunFunctionFmt(my_context, my_wire_to_event_fct_##A, "ppp", dpy, re, event);\
 }
 SUPER()
 #undef GO
@@ -149,7 +149,7 @@ static void* reverse_wire_to_eventFct(library_t* lib, void* fct)
 static uintptr_t my_event_to_wire_fct_##A = 0;                      \
 static int my_event_to_wire_##A(void* dpy, void* re, void* event)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_event_to_wire_fct_##A, 3, dpy, re, event);\
+    return (int)RunFunctionFmt(my_context, my_event_to_wire_fct_##A, "ppp", dpy, re, event);\
 }
 SUPER()
 #undef GO
@@ -182,7 +182,7 @@ static void* reverse_event_to_wireFct(library_t* lib, void* fct)
 static uintptr_t my_error_handler_fct_##A = 0;                      \
 static int my_error_handler_##A(void* dpy, void* error)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_error_handler_fct_##A, 2, dpy, error);\
+    return (int)RunFunctionFmt(my_context, my_error_handler_fct_##A, "pp", dpy, error);\
 }
 SUPER()
 #undef GO
@@ -215,7 +215,7 @@ static void* reverse_error_handlerFct(library_t* lib, void* fct)
 static uintptr_t my_ioerror_handler_fct_##A = 0;                      \
 static int my_ioerror_handler_##A(void* dpy)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_ioerror_handler_fct_##A, 1, dpy);\
+    return (int)RunFunctionFmt(my_context, my_ioerror_handler_fct_##A, "p", dpy);\
 }
 SUPER()
 #undef GO
@@ -248,7 +248,7 @@ static void* reverse_ioerror_handlerFct(library_t* lib, void* fct)
 static uintptr_t my_exterror_handler_fct_##A = 0;                      \
 static int my_exterror_handler_##A(void* dpy, void* err, void* codes, int* ret_code)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_exterror_handler_fct_##A, 4, dpy, err, codes, ret_code);\
+    return (int)RunFunctionFmt(my_context, my_exterror_handler_fct_##A, "pppp", dpy, err, codes, ret_code);\
 }
 SUPER()
 #undef GO
@@ -281,7 +281,7 @@ static void* reverse_exterror_handlerFct(library_t* lib, void* fct)
 static uintptr_t my_close_display_fct_##A = 0;                      \
 static int my_close_display_##A(void* dpy, void* codes)   \
 {                                                                   \
-    return (int)RunFunction(my_context, my_close_display_fct_##A, 2, dpy, codes);\
+    return (int)RunFunctionFmt(my_context, my_close_display_fct_##A, "pp", dpy, codes);\
 }
 SUPER()
 #undef GO
@@ -314,7 +314,7 @@ static void* reverse_close_displayFct(library_t* lib, void* fct)
 static uintptr_t my_register_im_fct_##A = 0;                        \
 static void my_register_im_##A(void* dpy, void* u, void* d)         \
 {                                                                   \
-    RunFunction(my_context, my_register_im_fct_##A, 3, dpy, u, d);  \
+    RunFunctionFmt(my_context, my_register_im_fct_##A, "ppp", dpy, u, d);  \
 }
 SUPER()
 #undef GO
@@ -347,7 +347,7 @@ static void* reverse_register_imFct(library_t* lib, void* fct)
 static uintptr_t my_XConnectionWatchProc_fct_##A = 0;                               \
 static void my_XConnectionWatchProc_##A(void* dpy, void* data, int op, void* d)     \
 {                                                                                   \
-    RunFunction(my_context, my_XConnectionWatchProc_fct_##A, 4, dpy, data, op, d);  \
+    RunFunctionFmt(my_context, my_XConnectionWatchProc_fct_##A, "ppip", dpy, data, op, d);  \
 }
 SUPER()
 #undef GO
@@ -369,7 +369,7 @@ static void* findXConnectionWatchProcFct(void* fct)
 static uintptr_t my_xifevent_fct_##A = 0;                                   \
 static int my_xifevent_##A(void* dpy, void* event, void* d)                 \
 {                                                                           \
-    return RunFunction(my_context, my_xifevent_fct_##A, 3, dpy, event, d);  \
+    return RunFunctionFmt(my_context, my_xifevent_fct_##A, "ppp", dpy, event, d);  \
 }
 SUPER()
 #undef GO
@@ -391,7 +391,7 @@ static void* findxifeventFct(void* fct)
 static uintptr_t my_XInternalAsyncHandler_fct_##A = 0;                                              \
 static int my_XInternalAsyncHandler_##A(void* dpy, void* rep, void* buf, int len, void* data)       \
 {                                                                                                   \
-    return RunFunction(my_context, my_XInternalAsyncHandler_fct_##A, 5, dpy, rep, buf, len, data);  \
+    return RunFunctionFmt(my_context, my_XInternalAsyncHandler_fct_##A, "pppip", dpy, rep, buf, len, data);  \
 }
 SUPER()
 #undef GO
@@ -414,7 +414,7 @@ static void* findXInternalAsyncHandlerFct(void* fct)
 static uintptr_t my_XSynchronizeProc_fct_##A = 0;                       \
 static int my_XSynchronizeProc_##A()                                    \
 {                                                                       \
-    return (int)RunFunction(my_context, my_XSynchronizeProc_fct_##A, 0);\
+    return (int)RunFunctionFmt(my_context, my_XSynchronizeProc_fct_##A, "");\
 }
 SUPER()
 #undef GO
@@ -447,7 +447,7 @@ static void* reverse_XSynchronizeProcFct(library_t* lib, void* fct)
 static uintptr_t my_XLockDisplay_fct_##A = 0;                   \
 static void my_XLockDisplay_##A(void* dpy)                      \
 {                                                               \
-    RunFunction(my_context, my_XLockDisplay_fct_##A, 1, dpy);   \
+    RunFunctionFmt(my_context, my_XLockDisplay_fct_##A, "p", dpy);   \
 }
 SUPER()
 #undef GO
@@ -469,7 +469,7 @@ static void* findXLockDisplayFct(void* fct)
 static uintptr_t my_XUnlockDisplay_fct_##A = 0;                 \
 static void my_XUnlockDisplay_##A(void* dpy)                    \
 {                                                               \
-    RunFunction(my_context, my_XUnlockDisplay_fct_##A, 1, dpy); \
+    RunFunctionFmt(my_context, my_XUnlockDisplay_fct_##A, "p", dpy); \
 }
 SUPER()
 #undef GO
@@ -556,14 +556,14 @@ static int my_XICProc_##A(void* a, void* b, void* c)                        \
 {                                                                           \
     if (my_XICProc_fct_##A == 0)                                            \
         printf_log(LOG_NONE, "%s cannot find XICProc callback\n", __func__);\
-    return (int)RunFunction(my_context, my_XICProc_fct_##A, 3, a, b, c);    \
+    return (int)RunFunctionFmt(my_context, my_XICProc_fct_##A, "ppp", a, b, c);    \
 }                                                                           \
 static uintptr_t my_XIMProc_fct_##A = 0;                                    \
 static void my_XIMProc_##A(void* a, void* b, void* c)                       \
 {                                                                           \
     if (my_XIMProc_fct_##A == 0)                                            \
         printf_log(LOG_NONE, "%s cannot find XIMProc callback\n", __func__);\
-    RunFunction(my_context, my_XIMProc_fct_##A, 3, a, b, c);                \
+    RunFunctionFmt(my_context, my_XIMProc_fct_##A, "ppp", a, b, c);                \
 }
 SUPER()
 #undef GO
@@ -666,7 +666,7 @@ EXPORT void* my_XSetICValues(x64emu_t* emu, void* xic, uintptr_t* va) {
         SUPER()
     }
 
-    void* res = NULL; 
+    void* res = NULL;
     VA_CALL(my->XSetICValues, xic, new_va, n, res);
     box_free(new_va);
     box_free(callbacks);
@@ -695,7 +695,7 @@ EXPORT void* my_XSetIMValues(x64emu_t* emu, void* xim, uintptr_t* va) {
         SUPER()
     }
     #undef GO
-    
+
     void* res = NULL;
     VA_CALL(my->XSetIMValues, xim, new_va, n, res)
     box_free(new_va);
@@ -792,7 +792,7 @@ void UnbridgeImageFunc(x64emu_t *emu, XImage *img)
 
 void sub_image_wrapper(x64emu_t *emu, uintptr_t fnc)
 {
-    pFpiiuu_t fn = (pFpiiuu_t)fnc; 
+    pFpiiuu_t fn = (pFpiiuu_t)fnc;
     void* img = fn(*(void**)(R_RDI), *(int32_t*)(R_RSI), *(int32_t*)(R_RDX), *(uint32_t*)(R_RCX), *(uint32_t*)(R_R8));
     BridgeImageFunc(emu, (XImage*)img);
     R_EAX=(uintptr_t)img;
@@ -903,7 +903,7 @@ EXPORT int my_XRegisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, v
 {
     return my->XRegisterIMInstantiateCallback(d, db, res_name, res_class, findregister_imFct(cb), data);
 }
-    
+
 EXPORT int my_XUnregisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data)
 {
     return my->XUnregisterIMInstantiateCallback(d, db, res_name, res_class, reverse_register_imFct(my_lib, cb), data);
diff --git a/src/wrapped/wrappedlibxext.c b/src/wrapped/wrappedlibxext.c
index efc2fba4..aaeaf749 100755
--- a/src/wrapped/wrappedlibxext.c
+++ b/src/wrapped/wrappedlibxext.c
@@ -56,7 +56,7 @@ GO(4)
 static uintptr_t my_exterrorhandle_fct_##A = 0;                                                 \
 static int my_exterrorhandle_##A(void* display, void* ext_name, void* reason)                   \
 {                                                                                               \
-    return RunFunction(my_context, my_exterrorhandle_fct_##A, 3, display, ext_name, reason);    \
+    return RunFunctionFmt(my_context, my_exterrorhandle_fct_##A, "ppp", display, ext_name, reason);    \
 }
 SUPER()
 #undef GO
@@ -137,57 +137,57 @@ static uintptr_t my_hook_error_fnc = 0;
 static uintptr_t my_hook_error_string_fnc = 0;
 static int  my_hook_create_gc(void* a, uint32_t b, void* c) {
     if(my_hook_create_gc_fnc)
-        return (int)RunFunction(context, my_hook_create_gc_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_create_gc_fnc, "pup", a, b, c);
     return 0;
 }
 static int  my_hook_copy_gc(void* a, uint32_t b, void* c) {
     if(my_hook_copy_gc_fnc)
-        return (int)RunFunction(context, my_hook_copy_gc_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_copy_gc_fnc, "pup", a, b, c);
     return 0;
 }
 static int  my_hook_flush_gc(void* a, uint32_t b, void* c) {
     if(my_hook_flush_gc_fnc)
-        return (int)RunFunction(context, my_hook_flush_gc_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_flush_gc_fnc, "pup", a, b, c);
     return 0;
 }
 static int  my_hook_free_gc(void* a, uint32_t b, void* c) {
     if(my_hook_free_gc_fnc)
-        return (int)RunFunction(context, my_hook_free_gc_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_free_gc_fnc, "pup", a, b, c);
     return 0;
 }
 static int  my_hook_create_font(void* a, void* b, void* c) {
     if(my_hook_create_font_fnc)
-        return (int)RunFunction(context, my_hook_create_font_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_create_font_fnc, "ppp", a, b, c);
     return 0;
 }
 static int  my_hook_free_font(void* a, void* b, void* c) {
     if(my_hook_free_font_fnc)
-        return (int)RunFunction(context, my_hook_free_font_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_free_font_fnc, "ppp", a, b, c);
     return 0;
 }
 static int  my_hook_close_display(void* a, void* b) {
     if(my_hook_close_display_fnc)
-        return (int)RunFunction(context, my_hook_close_display_fnc, 2, a, b);
+        return (int)RunFunctionFmt(context, my_hook_close_display_fnc, "pp", a, b);
     return 0;
 }
 static int  my_hook_wire_to_event(void* a, void* b, void* c) {
     if(my_hook_wire_to_event_fnc)
-        return (int)RunFunction(context, my_hook_wire_to_event_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_wire_to_event_fnc, "ppp", a, b, c);
     return 0;
 }
 static int  my_hook_event_to_wire(void* a, void* b, void* c) {
     if(my_hook_event_to_wire_fnc)
-        return (int)RunFunction(context, my_hook_event_to_wire_fnc, 3, a, b, c);
+        return (int)RunFunctionFmt(context, my_hook_event_to_wire_fnc, "ppp", a, b, c);
     return 0;
 }
 static int  my_hook_error(void* a, void* b, void* c, int* d) {
     if(my_hook_error_fnc)
-        return (int)RunFunction(context, my_hook_error_fnc, 4, a, b, c, d);
+        return (int)RunFunctionFmt(context, my_hook_error_fnc, "pppp", a, b, c, d);
     return 0;
 }
 static char* my_hook_error_string(void* a, int b, void* c, void* d, int e) {
     if(my_hook_error_string_fnc)
-        return (char*)RunFunction(context, my_hook_error_string_fnc, 5, a, b, c, d, e);
+        return (char*)RunFunctionFmt(context, my_hook_error_string_fnc, "pippi", a, b, c, d, e);
     return 0;
 }
 
diff --git a/src/wrapped/wrappedlibxt.c b/src/wrapped/wrappedlibxt.c
index 6177ae84..526f79ba 100755
--- a/src/wrapped/wrappedlibxt.c
+++ b/src/wrapped/wrappedlibxt.c
@@ -39,7 +39,7 @@ GO(7)
 static uintptr_t my_Event_fct_##A = 0;   \
 static void my_Event_##A(void* w, void* data, void* event)     \
 {                                       \
-    RunFunction(my_context, my_Event_fct_##A, 3, w, data, event);\
+    RunFunctionFmt(my_context, my_Event_fct_##A, "ppp", w, data, event);\
 }
 SUPER()
 #undef GO
@@ -61,7 +61,7 @@ static void* findEventFct(void* fct)
 static uintptr_t my_WorkProc_fct_##A = 0;   \
 static int my_WorkProc_##A(void* p)         \
 {                                           \
-    return (int)RunFunction(my_context, my_WorkProc_fct_##A, 1, p);\
+    return (int)RunFunctionFmt(my_context, my_WorkProc_fct_##A, "p", p);\
 }
 SUPER()
 #undef GO
@@ -83,7 +83,7 @@ static void* findWorkProcFct(void* fct)
 static uintptr_t my_InputCallback_fct_##A = 0;                      \
 static void my_InputCallback_##A(void* p, void* s, void* id)        \
 {                                                                   \
-    RunFunction(my_context, my_InputCallback_fct_##A, 3, p, s, id); \
+    RunFunctionFmt(my_context, my_InputCallback_fct_##A, "ppp", p, s, id); \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibxtst.c b/src/wrapped/wrappedlibxtst.c
index eaec1de6..6ba9ee66 100755
--- a/src/wrapped/wrappedlibxtst.c
+++ b/src/wrapped/wrappedlibxtst.c
@@ -36,7 +36,7 @@ GO(4)
 static uintptr_t my_XRecordInterceptProc_fct_##A = 0;                   \
 static void my_XRecordInterceptProc_##A(void* a, void* b)               \
 {                                                                       \
-    RunFunction(my_context, my_XRecordInterceptProc_fct_##A, 2, a, b);  \
+    RunFunctionFmt(my_context, my_XRecordInterceptProc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedlibz.c b/src/wrapped/wrappedlibz.c
index 8d3ebb7a..a8184e11 100755
--- a/src/wrapped/wrappedlibz.c
+++ b/src/wrapped/wrappedlibz.c
@@ -34,7 +34,7 @@ GO(4)
 static uintptr_t my_alloc_fct_##A = 0;                                          \
 static void* my_alloc_##A(void* opaque, uint32_t items, uint32_t size)                  \
 {                                                                                       \
-    return (void*)RunFunction(my_context, my_alloc_fct_##A, 3, opaque, items, size);    \
+    return (void*)RunFunctionFmt(my_context, my_alloc_fct_##A, "puu", opaque, items, size);    \
 }
 SUPER()
 #undef GO
@@ -56,7 +56,7 @@ static void* find_alloc_Fct(void* fct)
 static uintptr_t my_free_fct_##A = 0;                               \
 static void my_free_##A(void* opaque, void* address)                \
 {                                                                   \
-    RunFunction(my_context, my_free_fct_##A, 2, opaque, address);   \
+    RunFunctionFmt(my_context, my_free_fct_##A, "pp", opaque, address);   \
 }
 SUPER()
 #undef GO
@@ -76,7 +76,7 @@ static void* find_free_Fct(void* fct)
 #undef SUPER
 
 typedef struct z_stream_s {
-    void *next_in;   
+    void *next_in;
     uint32_t     avail_in;
     uintptr_t    total_in;
     void    *next_out;
@@ -85,11 +85,11 @@ typedef struct z_stream_s {
     char *msg;
     void *state;
     void* zalloc;
-    void*  zfree; 
+    void*  zfree;
     void*     opaque;
     int32_t     data_type;
-    uintptr_t   adler;    
-    uintptr_t   reserved; 
+    uintptr_t   adler;
+    uintptr_t   reserved;
 } z_stream;
 
 static void wrapper_stream_z(x64emu_t* emu, void* str)
diff --git a/src/wrapped/wrappedlzma.c b/src/wrapped/wrappedlzma.c
index ad796fcf..b7839e3c 100755
--- a/src/wrapped/wrappedlzma.c
+++ b/src/wrapped/wrappedlzma.c
@@ -64,7 +64,7 @@ GO(4)
 static uintptr_t my_alloc_fct_##A = 0;                                              \
 static void* my_alloc_##A(void* opaque, size_t items, size_t size)                  \
 {                                                                                   \
-    return (void*)RunFunction(my_context, my_alloc_fct_##A, 3, opaque, items, size);\
+    return (void*)RunFunctionFmt(my_context, my_alloc_fct_##A, "pLL", opaque, items, size);\
 }
 SUPER()
 #undef GO
@@ -86,7 +86,7 @@ static void* find_alloc_Fct(void* fct)
 static uintptr_t my_free_fct_##A = 0;                               \
 static void my_free_##A(void* opaque, void* address)                \
 {                                                                   \
-    RunFunction(my_context, my_free_fct_##A, 2, opaque, address);   \
+    RunFunctionFmt(my_context, my_free_fct_##A, "pp", opaque, address);   \
 }
 SUPER()
 #undef GO
@@ -112,7 +112,7 @@ static void wrap_alloc_struct(lzma_allocator_t* dst, lzma_allocator_t* src)
     dst->opaque = src->opaque;
     dst->alloc = find_alloc_Fct(src->alloc);
     dst->free = find_free_Fct(src->free);
-    
+
 }
 
 EXPORT int my_lzma_index_buffer_decode(x64emu_t* emu, void* i, void* memlimit, lzma_allocator_t* alloc, void* in_, void* in_pos, size_t in_size)
diff --git a/src/wrapped/wrappedmpg123.c b/src/wrapped/wrappedmpg123.c
index 6ddaf394..6aee0935 100755
--- a/src/wrapped/wrappedmpg123.c
+++ b/src/wrapped/wrappedmpg123.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_r_read_fct_##A = 0;                                 \
 static ssize_t my_r_read_##A(void* a, void* b, size_t n)             \
 {                                                                                       \
-    return (ssize_t)RunFunction(my_context, my_r_read_fct_##A, 3, a, b, n); \
+    return (ssize_t)RunFunctionFmt(my_context, my_r_read_fct_##A, "ppL", a, b, n); \
 }
 SUPER()
 #undef GO
@@ -60,7 +60,7 @@ static void* find_r_read_Fct(void* fct)
 static uintptr_t my_r_lseek_fct_##A = 0;                                 \
 static int64_t my_r_lseek_##A(void* a, int64_t b, int n)             \
 {                                                                                       \
-    return (int64_t)RunFunction(my_context, my_r_lseek_fct_##A, 3, a, b, n); \
+    return (int64_t)RunFunctionFmt(my_context, my_r_lseek_fct_##A, "pIi", a, b, n); \
 }
 SUPER()
 #undef GO
@@ -82,7 +82,7 @@ static void* find_r_lseek_Fct(void* fct)
 static uintptr_t my_cleanup_fct_##A = 0;                \
 static void my_cleanup_##A(void* a)                     \
 {                                                       \
-    RunFunction(my_context, my_cleanup_fct_##A, 1, a);  \
+    RunFunctionFmt(my_context, my_cleanup_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappednss3.c b/src/wrapped/wrappednss3.c
index 00a0766f..4aedaf77 100755
--- a/src/wrapped/wrappednss3.c
+++ b/src/wrapped/wrappednss3.c
@@ -37,7 +37,7 @@ GO(4)
 static uintptr_t my_PK11PasswordFunc_fct_##A = 0;                                   \
 static void* my_PK11PasswordFunc_##A(void* a, int b, void* c)                       \
 {                                                                                   \
-    return (void*)RunFunction(my_context, my_PK11PasswordFunc_fct_##A, 3, a, b, c); \
+    return (void*)RunFunctionFmt(my_context, my_PK11PasswordFunc_fct_##A, "pip", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -60,7 +60,7 @@ static void* find_PK11PasswordFunc_Fct(void* fct)
 static uintptr_t my_CERT_StringFromCertFcn_fct_##A = 0;                             \
 static void* my_CERT_StringFromCertFcn_##A(void* a)                                 \
 {                                                                                   \
-    return (void*)RunFunction(my_context, my_CERT_StringFromCertFcn_fct_##A, 1, a); \
+    return (void*)RunFunctionFmt(my_context, my_CERT_StringFromCertFcn_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -92,7 +92,7 @@ static void* reverse_CERT_StringFromCertFcn_Fct(library_t* lib, void* fct)
 static uintptr_t my_CERTChainVerifyCallbackFunc_fct_##A = 0;                                    \
 static int my_CERTChainVerifyCallbackFunc_##A(void* a, void* b, void* c)                        \
 {                                                                                               \
-    return (int)RunFunction(my_context, my_CERTChainVerifyCallbackFunc_fct_##A, 3, a, b, c);    \
+    return (int)RunFunctionFmt(my_context, my_CERTChainVerifyCallbackFunc_fct_##A, "ppp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -124,7 +124,7 @@ static void* reverse_CERTChainVerifyCallbackFunc_Fct(library_t* lib, void* fct)
 static uintptr_t my_PORTCharConversionWSwapFunc_fct_##A = 0;                                                    \
 static int my_PORTCharConversionWSwapFunc_##A(int a, void* b, uint32_t c, void* d, uint32_t e, void* f, int g)  \
 {                                                                                                               \
-    return (int)RunFunction(my_context, my_PORTCharConversionWSwapFunc_fct_##A, 7, a, b, c, d, e, f, g);        \
+    return (int)RunFunctionFmt(my_context, my_PORTCharConversionWSwapFunc_fct_##A, "ipupupi", a, b, c, d, e, f, g);        \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedopenal.c b/src/wrapped/wrappedopenal.c
index 96cc1bb6..4d65fdd8 100755
--- a/src/wrapped/wrappedopenal.c
+++ b/src/wrapped/wrappedopenal.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_Request_fct_##A = 0;                    \
 static void my_Request_##A(int32_t a, int32_t b)            \
 {                                                           \
-    RunFunction(my_context, my_Request_fct_##A, 2, a, b);   \
+    RunFunctionFmt(my_context, my_Request_fct_##A, "ii", a, b);   \
 }
 SUPER()
 #undef GO
@@ -113,7 +113,7 @@ void freeALProcWrapper(box64context_t* context)
     context->almymap = NULL;
 }
 
-EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name) 
+EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
@@ -130,7 +130,7 @@ EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name)
         strcpy(tmp, "my_");
         strcat(tmp, rname);
         symbol = dlsym(emu->context->box64lib, tmp);
-    } else 
+    } else
         symbol = my->alGetProcAddress(name);
     if(!symbol)
         return NULL;    // easy
@@ -138,7 +138,7 @@ EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name)
     uintptr_t ret = CheckBridged(emu->context->system, symbol);
     if(ret)
         return (void*)ret; // already bridged
-    // get wrapper    
+    // get wrapper
     k = kh_get(symbolmap, emu->context->alwrappers, rname);
     if(k==kh_end(emu->context->alwrappers)) {
         printf_log(LOG_INFO, "Warning, no wrapper for %s\n", rname);
@@ -166,14 +166,14 @@ EXPORT void* my_alcGetProcAddress(x64emu_t* emu, void* device, void* name)
         strcpy(tmp, "my_");
         strcat(tmp, rname);
         symbol = dlsym(emu->context->box64lib, tmp);
-    } else 
+    } else
         symbol = my->alcGetProcAddress(device, name);
     if(!symbol)
         return NULL;    // easy
     uintptr_t ret = CheckBridged(emu->context->system, symbol);
     if(ret)
         return (void*)ret; // already bridged
-    // get wrapper    
+    // get wrapper
     k = kh_get(symbolmap, emu->context->alwrappers, rname);
     if(k==kh_end(emu->context->alwrappers)) {
         printf_log(LOG_INFO, "Warning, no wrapper for %s\n", rname);
diff --git a/src/wrapped/wrappedpango.c b/src/wrapped/wrappedpango.c
index dc0ccf41..84cb8d60 100755
--- a/src/wrapped/wrappedpango.c
+++ b/src/wrapped/wrappedpango.c
@@ -46,17 +46,17 @@ static my_PangoAttrClass_t my_PangoAttrClass_struct_##A = {0};  \
 static uintptr_t my_PangoAttrClass_copy_##A = 0;                \
 static void* my_PangoAttrClass_copyfct##A(void* attr)           \
 {                                                               \
-    return (void*)RunFunction(my_context, my_PangoAttrClass_copy_##A, 1, attr);  \
+    return (void*)RunFunctionFmt(my_context, my_PangoAttrClass_copy_##A, "p", attr);  \
 }                                                               \
 static uintptr_t my_PangoAttrClass_del_##A = 0;                 \
 static void my_PangoAttrClass_delfct##A(void* attr)             \
 {                                                               \
-    RunFunction(my_context, my_PangoAttrClass_del_##A, 1, attr);\
+    RunFunctionFmt(my_context, my_PangoAttrClass_del_##A, "p", attr);\
 }                                                               \
 static uintptr_t my_PangoAttrClass_equal_##A = 0;               \
 static int my_PangoAttrClass_equalfct##A(void* a, void* b)      \
 {                                                               \
-    return (int)RunFunction(my_context, my_PangoAttrClass_equal_##A, 2, a, b);\
+    return (int)RunFunctionFmt(my_context, my_PangoAttrClass_equal_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedpng16.c b/src/wrapped/wrappedpng16.c
index 22bb9e5a..25989689 100755
--- a/src/wrapped/wrappedpng16.c
+++ b/src/wrapped/wrappedpng16.c
@@ -41,7 +41,7 @@ GO(3)
 static uintptr_t my_user_write_fct_##A = 0;   \
 static void my_user_write_##A(void* png_ptr, void* data, int32_t length)    \
 {                                       \
-    RunFunction(my_context, my_user_write_fct_##A, 3, png_ptr, data, length);\
+    RunFunctionFmt(my_context, my_user_write_fct_##A, "ppi", png_ptr, data, length);\
 }
 SUPER()
 #undef GO
@@ -63,7 +63,7 @@ static void* finduser_writeFct(void* fct)
 static uintptr_t my_user_flush_fct_##A = 0;   \
 static void my_user_flush_##A(void* png_ptr)    \
 {                                       \
-    RunFunction(my_context, my_user_flush_fct_##A, 1, png_ptr);\
+    RunFunctionFmt(my_context, my_user_flush_fct_##A, "p", png_ptr);\
 }
 SUPER()
 #undef GO
@@ -85,7 +85,7 @@ static void* finduser_flushFct(void* fct)
 static uintptr_t my_user_read_fct_##A = 0;   \
 static void my_user_read_##A(void* png_ptr, void* data, int32_t length)    \
 {                                       \
-    RunFunction(my_context, my_user_read_fct_##A, 3, png_ptr, data, length);\
+    RunFunctionFmt(my_context, my_user_read_fct_##A, "ppi", png_ptr, data, length);\
 }
 SUPER()
 #undef GO
@@ -107,7 +107,7 @@ static void* finduser_readFct(void* fct)
 static uintptr_t my_error_fct_##A = 0;   \
 static void my_error_##A(void* a, void* b)    \
 {                                       \
-    RunFunction(my_context, my_error_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_error_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -129,7 +129,7 @@ static void* finderrorFct(void* fct)
 static uintptr_t my_warning_fct_##A = 0;   \
 static void my_warning_##A(void* a, void* b)    \
 {                                       \
-    RunFunction(my_context, my_warning_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_warning_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -151,7 +151,7 @@ static void* findwarningFct(void* fct)
 static uintptr_t my_malloc_fct_##A = 0;   \
 static void my_malloc_##A(void* a, unsigned long b)    \
 {                                       \
-    RunFunction(my_context, my_malloc_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_malloc_fct_##A, "pL", a, b);\
 }
 SUPER()
 #undef GO
@@ -173,7 +173,7 @@ static void* findmallocFct(void* fct)
 static uintptr_t my_free_fct_##A = 0;   \
 static void my_free_##A(void* a, void* b)    \
 {                                       \
-    RunFunction(my_context, my_free_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_free_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -196,7 +196,7 @@ static void* findfreeFct(void* fct)
 static uintptr_t my_progressive_info_fct_##A = 0;   \
 static void my_progressive_info_##A(void* a, void* b)    \
 {                                       \
-    RunFunction(my_context, my_progressive_info_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_progressive_info_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -219,7 +219,7 @@ static void* findprogressive_infoFct(void* fct)
 static uintptr_t my_progressive_end_fct_##A = 0;   \
 static void my_progressive_end_##A(void* a, void* b)    \
 {                                       \
-    RunFunction(my_context, my_progressive_end_fct_##A, 2, a, b);\
+    RunFunctionFmt(my_context, my_progressive_end_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -242,7 +242,7 @@ static void* findprogressive_endFct(void* fct)
 static uintptr_t my_progressive_row_fct_##A = 0;   \
 static void my_progressive_row_##A(void* a, void* b, uint32_t c, int d)    \
 {                                       \
-    RunFunction(my_context, my_progressive_row_fct_##A, 4, a, b, c, d);\
+    RunFunctionFmt(my_context, my_progressive_row_fct_##A, "ppui", a, b, c, d);\
 }
 SUPER()
 #undef GO
@@ -266,7 +266,7 @@ static void* findprogressive_rowFct(void* fct)
 static uintptr_t my_user_transform_fct_##A = 0;   \
 static void my_user_transform_##A(void* ptr, void* row, void* data)    \
 {                                       \
-    RunFunction(my_context, my_user_transform_fct_##A, 3, ptr, row, data);\
+    RunFunctionFmt(my_context, my_user_transform_fct_##A, "ppp", ptr, row, data);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedpulse.c b/src/wrapped/wrappedpulse.c
index 50bd3a3f..e80e2f91 100755
--- a/src/wrapped/wrappedpulse.c
+++ b/src/wrapped/wrappedpulse.c
@@ -49,7 +49,7 @@ typedef void (*vFipippV_t)(int, void*, int, void*, void*, va_list);
 #else
 typedef void (*vFipippV_t)(int, void*, int, void*, void*, void*);
 #endif
-    GO(pa_log_level_meta, vFipippV_t)           
+    GO(pa_log_level_meta, vFipippV_t)
 #endif
 
 #define ADDED_FUNCTIONS() \
@@ -91,7 +91,7 @@ GO(15)  \
 static uintptr_t my_free_fct_##A = 0;   \
 static void my_free_##A(void* data)     \
 {                                       \
-    RunFunction(my_context, my_free_fct_##A, 1, data);\
+    RunFunctionFmt(my_context, my_free_fct_##A, "p", data);\
 }
 SUPER()
 #undef GO
@@ -113,7 +113,7 @@ static void* findFreeFct(void* fct)
 static uintptr_t my_free_api_fct_##A = 0;   \
 static void my_free_api_##A(my_pa_mainloop_api_t* api, void* p, void* data)     \
 {                                       \
-    RunFunction(my_context, my_free_api_fct_##A, 3, api, p, data);\
+    RunFunctionFmt(my_context, my_free_api_fct_##A, "ppp", api, p, data);\
 }
 SUPER()
 #undef GO
@@ -136,7 +136,7 @@ static uintptr_t my_io_event_fct_##A = 0;   \
 static void my_io_event_##A(my_pa_mainloop_api_t* api, void* e, int fd, int events, void* data)     \
 {                                       \
     if(api==my_mainloop_orig) api=my_mainloop_ref;                  \
-    RunFunction(my_context, my_io_event_fct_##A, 5, api, e, fd, events, data);  \
+    RunFunctionFmt(my_context, my_io_event_fct_##A, "ppiip", api, e, fd, events, data);  \
 }
 SUPER()
 #undef GO
@@ -159,7 +159,7 @@ static uintptr_t my_time_event_fct_##A = 0;   \
 static void my_time_event_##A(my_pa_mainloop_api_t* api, void* e, void* tv, void* data)     \
 {                                       \
     if(api==my_mainloop_orig) api=my_mainloop_ref;                  \
-    RunFunction(my_context, my_time_event_fct_##A, 4, api, e, tv, data);  \
+    RunFunctionFmt(my_context, my_time_event_fct_##A, "pppp", api, e, tv, data);  \
 }
 SUPER()
 #undef GO
@@ -183,7 +183,7 @@ static uintptr_t my_defer_event_fct_##A = 0;   \
 static void my_defer_event_##A(my_pa_mainloop_api_t* api, void* e, void* data)     \
 {                                       \
     if(api==my_mainloop_orig) api=my_mainloop_ref;                  \
-    RunFunction(my_context, my_defer_event_fct_##A, 3, api, e, data);  \
+    RunFunctionFmt(my_context, my_defer_event_fct_##A, "ppp", api, e, data);  \
 }
 SUPER()
 #undef GO
@@ -206,7 +206,7 @@ static void* findDeferEventFct(void* fct)
 static uintptr_t my_poll_fct_##A = 0;   \
 static int my_poll_##A(void* ufds, unsigned long nfds, int timeout, void* data)         \
 {                                       \
-    return (int)RunFunction(my_context, my_poll_fct_##A, 4, ufds, nfds, timeout, data); \
+    return (int)RunFunctionFmt(my_context, my_poll_fct_##A, "pLip", ufds, nfds, timeout, data); \
 }
 SUPER()
 #undef GO
@@ -229,7 +229,7 @@ static uintptr_t my_signal_fct_##A = 0;   \
 static void my_signal_##A(my_pa_mainloop_api_t* api, void* e, int sig, void *data)  \
 {                                                                                   \
     if(api==my_mainloop_orig) api=my_mainloop_ref;                                  \
-    RunFunction(my_context, my_signal_fct_##A, 4, api, e, sig, data);               \
+    RunFunctionFmt(my_context, my_signal_fct_##A, "ppip", api, e, sig, data);               \
 }
 SUPER()
 #undef GO
@@ -252,7 +252,7 @@ static uintptr_t my_signal_destroy_fct_##A = 0;   \
 static void my_signal_destroy_##A(my_pa_mainloop_api_t* api, void* e, void *data)   \
 {                                                                                   \
     if(api==my_mainloop_orig) api=my_mainloop_ref;                                  \
-    RunFunction(my_context, my_signal_destroy_fct_##A, 3, api, e, data);            \
+    RunFunctionFmt(my_context, my_signal_destroy_fct_##A, "ppp", api, e, data);            \
 }
 SUPER()
 #undef GO
@@ -275,7 +275,7 @@ static void* find_signal_destroy_Fct(void* fct)
 static uintptr_t my_prefork_fct_##A = 0;            \
 static void my_prefork_##A()                        \
 {                                                   \
-    RunFunction(my_context, my_prefork_fct_##A, 0); \
+    RunFunctionFmt(my_context, my_prefork_fct_##A, ""); \
 }
 SUPER()
 #undef GO
@@ -297,7 +297,7 @@ static void* find_prefork_Fct(void* fct)
 static uintptr_t my_postfork_fct_##A = 0;           \
 static void my_postfork_##A()                       \
 {                                                   \
-    RunFunction(my_context, my_postfork_fct_##A, 0);\
+    RunFunctionFmt(my_context, my_postfork_fct_##A, "");\
 }
 SUPER()
 #undef GO
@@ -319,7 +319,7 @@ static void* find_postfork_Fct(void* fct)
 static uintptr_t my_atfork_fct_##A = 0;             \
 static void my_atfork_##A()                         \
 {                                                   \
-    RunFunction(my_context, my_atfork_fct_##A, 0);  \
+    RunFunctionFmt(my_context, my_atfork_fct_##A, "");  \
 }
 SUPER()
 #undef GO
@@ -342,7 +342,7 @@ static void* find_atfork_Fct(void* fct)
 static uintptr_t my_state_context_fct_##A = 0;                              \
 static void my_state_context_##A(void* context, void* data)                 \
 {                                                                           \
-    RunFunction(my_context, my_state_context_fct_##A, 2, context, data);    \
+    RunFunctionFmt(my_context, my_state_context_fct_##A, "pp", context, data);    \
 }
 SUPER()
 #undef GO
@@ -364,7 +364,7 @@ static void* find_state_context_Fct(void* fct)
 static uintptr_t my_notify_context_fct_##A = 0;                             \
 static void my_notify_context_##A(void* context, void* data)                \
 {                                                                           \
-    RunFunction(my_context, my_notify_context_fct_##A, 2, context, data);   \
+    RunFunctionFmt(my_context, my_notify_context_fct_##A, "pp", context, data);   \
 }
 SUPER()
 #undef GO
@@ -386,7 +386,7 @@ static void* find_notify_context_Fct(void* fct)
 static uintptr_t my_success_context_fct_##A = 0;                                    \
 static void my_success_context_##A(void* context, int success, void* data)          \
 {                                                                                   \
-    RunFunction(my_context, my_success_context_fct_##A, 3, context, success, data); \
+    RunFunctionFmt(my_context, my_success_context_fct_##A, "pip", context, success, data); \
 }
 SUPER()
 #undef GO
@@ -408,7 +408,7 @@ static void* find_success_context_Fct(void* fct)
 static uintptr_t my_event_context_fct_##A = 0;                                      \
 static void my_event_context_##A(void* context, void* name, void* p, void* data)    \
 {                                                                                   \
-    RunFunction(my_context, my_event_context_fct_##A, 4, context, name, p, data);   \
+    RunFunctionFmt(my_context, my_event_context_fct_##A, "pppp", context, name, p, data);   \
 }
 SUPER()
 #undef GO
@@ -430,7 +430,7 @@ static void* find_event_context_Fct(void* fct)
 static uintptr_t my_module_info_fct_##A = 0;                                    \
 static void my_module_info_##A(void* context, void* i, int eol, void* data)     \
 {                                                                               \
-    RunFunction(my_context, my_module_info_fct_##A, 4, context, i, eol, data);  \
+    RunFunctionFmt(my_context, my_module_info_fct_##A, "ppip", context, i, eol, data);  \
 }
 SUPER()
 #undef GO
@@ -452,7 +452,7 @@ static void* find_module_info_Fct(void* fct)
 static uintptr_t my_server_info_fct_##A = 0;                                \
 static void my_server_info_##A(void* context, void* i, void* data)          \
 {                                                                           \
-    RunFunction(my_context, my_server_info_fct_##A, 3, context, i, data);   \
+    RunFunctionFmt(my_context, my_server_info_fct_##A, "ppp", context, i, data);   \
 }
 SUPER()
 #undef GO
@@ -474,7 +474,7 @@ static void* find_server_info_Fct(void* fct)
 static uintptr_t my_client_info_fct_##A = 0;                                    \
 static void my_client_info_##A(void* context, void* i, int eol, void* data)     \
 {                                                                               \
-    RunFunction(my_context, my_client_info_fct_##A, 4, context, i, eol, data);  \
+    RunFunctionFmt(my_context, my_client_info_fct_##A, "ppip", context, i, eol, data);  \
 }
 SUPER()
 #undef GO
@@ -496,7 +496,7 @@ static void* find_client_info_Fct(void* fct)
 static uintptr_t my_context_index_fct_##A = 0;                                  \
 static void my_context_index_##A(void* context, uint32_t idx, void* data)       \
 {                                                                               \
-    RunFunction(my_context, my_context_index_fct_##A, 3, context, idx, data);   \
+    RunFunctionFmt(my_context, my_context_index_fct_##A, "pup", context, idx, data);   \
 }
 SUPER()
 #undef GO
@@ -518,7 +518,7 @@ static void* find_context_index_Fct(void* fct)
 static uintptr_t my_subscribe_context_fct_##A = 0;                                      \
 static void my_subscribe_context_##A(void* context, int evt, uint32_t idx, void* data)  \
 {                                                                                       \
-    RunFunction(my_context, my_subscribe_context_fct_##A, 4, context, evt, idx, data);  \
+    RunFunctionFmt(my_context, my_subscribe_context_fct_##A, "piup", context, evt, idx, data);  \
 }
 SUPER()
 #undef GO
@@ -541,7 +541,7 @@ static void* find_subscribe_context_Fct(void* fct)
 static uintptr_t my_stream_state_fct_##A = 0;                       \
 static void my_stream_state_##A(void* s, void* data)                \
 {                                                                   \
-    RunFunction(my_context, my_stream_state_fct_##A, 2, s, data);   \
+    RunFunctionFmt(my_context, my_stream_state_fct_##A, "pp", s, data);   \
 }
 SUPER()
 #undef GO
@@ -563,7 +563,7 @@ static void* find_stream_state_Fct(void* fct)
 static uintptr_t my_stream_success_fct_##A = 0;                                 \
 static void my_stream_success_##A(void* s, int success, void* data)             \
 {                                                                               \
-    RunFunction(my_context, my_stream_success_fct_##A, 3, s, success, data);    \
+    RunFunctionFmt(my_context, my_stream_success_fct_##A, "pip", s, success, data);    \
 }
 SUPER()
 #undef GO
@@ -585,7 +585,7 @@ static void* find_stream_success_Fct(void* fct)
 static uintptr_t my_stream_notify_fct_##A = 0;                      \
 static void my_stream_notify_##A(void* s, void* data)               \
 {                                                                   \
-    RunFunction(my_context, my_stream_notify_fct_##A, 2, s, data);  \
+    RunFunctionFmt(my_context, my_stream_notify_fct_##A, "pp", s, data);  \
 }
 SUPER()
 #undef GO
@@ -607,7 +607,7 @@ static void* find_stream_notify_Fct(void* fct)
 static uintptr_t my_stream_event_fct_##A = 0;                               \
 static void my_stream_event_##A(void* s, void* name, void* pl, void* data)  \
 {                                                                           \
-    RunFunction(my_context, my_stream_event_fct_##A, 4, s, name, pl, data); \
+    RunFunctionFmt(my_context, my_stream_event_fct_##A, "pppp", s, name, pl, data); \
 }
 SUPER()
 #undef GO
@@ -629,7 +629,7 @@ static void* find_stream_event_Fct(void* fct)
 static uintptr_t my_stream_request_fct_##A = 0;                             \
 static void my_stream_request_##A(void* s, size_t nbytes, void* data)       \
 {                                                                           \
-    RunFunction(my_context, my_stream_request_fct_##A, 3, s, nbytes, data); \
+    RunFunctionFmt(my_context, my_stream_request_fct_##A, "pLp", s, nbytes, data); \
 }
 SUPER()
 #undef GO
@@ -651,7 +651,7 @@ static void* find_stream_request_Fct(void* fct)
 static uintptr_t my_device_restore_read_device_formats_fct_##A = 0;                         \
 static void my_device_restore_read_device_formats_##A(void* a, void* b, int c, void* d)     \
 {                                                                                           \
-    RunFunction(my_context, my_device_restore_read_device_formats_fct_##A, 4, a, b, c, d);  \
+    RunFunctionFmt(my_context, my_device_restore_read_device_formats_fct_##A, "ppip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -673,7 +673,7 @@ static void* find_device_restore_read_device_formats_Fct(void* fct)
 static uintptr_t my_card_info_fct_##A = 0;                         \
 static void my_card_info_##A(void* a, void* b, int c, void* d)     \
 {                                                                  \
-    RunFunction(my_context, my_card_info_fct_##A, 4, a, b, c, d);  \
+    RunFunctionFmt(my_context, my_card_info_fct_##A, "ppip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -695,7 +695,7 @@ static void* find_card_info_Fct(void* fct)
 static uintptr_t my_source_output_info_fct_##A = 0;                         \
 static void my_source_output_info_##A(void* a, void* b, int c, void* d)     \
 {                                                                  \
-    RunFunction(my_context, my_source_output_info_fct_##A, 4, a, b, c, d);  \
+    RunFunctionFmt(my_context, my_source_output_info_fct_##A, "ppip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -717,7 +717,7 @@ static void* find_source_output_info_Fct(void* fct)
 static uintptr_t my_device_restore_subscribe_fct_##A = 0;                           \
 static void my_device_restore_subscribe_##A(void* a, int b, uint32_t c, void* d)    \
 {                                                                                   \
-    RunFunction(my_context, my_device_restore_subscribe_fct_##A, 4, a, b, c, d);    \
+    RunFunctionFmt(my_context, my_device_restore_subscribe_fct_##A, "piup", a, b, c, d);    \
 }
 SUPER()
 #undef GO
@@ -830,7 +830,7 @@ static void* my_io_new(void* api, int fd, int events, void* cb, void *userdata)
     if(cb)
         b = AddCheckBridge(bridge, vFppiip, cb, 0, NULL);
     if(api==my_mainloop_orig) api=my_mainloop_ref;    // need emulated version
-    return (void*)RunFunction(my_context, (uintptr_t)my_mainloop_ref->io_new, 5, api, fd, events, b, userdata);
+    return (void*)RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->io_new, "piipp", api, fd, events, b, userdata);
 }
 static void my_io_enable(void* e, int events)
 {
@@ -839,7 +839,7 @@ static void my_io_enable(void* e, int events)
     if(fnc)
         return ((vFpi_t)fnc)(e, events);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->io_enable, 2, e, events);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->io_enable, "pi", e, events);
 }
 static void my_io_free(void* e)
 {
@@ -848,7 +848,7 @@ static void my_io_free(void* e)
     if(fnc)
         return ((vFp_t)fnc)(e);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->io_free, 1, e);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->io_free, "p", e);
 }
 static void my_io_set_destroy(void* e, void* cb)
 {
@@ -864,7 +864,7 @@ static void my_io_set_destroy(void* e, void* cb)
         if(!b)
             b = AddBridge(bridge, vFppp, cb, 0, NULL);
     }
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->io_set_destroy, 2, e, b);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->io_set_destroy, "pp", e, b);
 }
 
 static void* my_time_new(void* api, void* tv, void* cb, void* data)
@@ -882,7 +882,7 @@ static void* my_time_new(void* api, void* tv, void* cb, void* data)
     if(cb)
         b = AddCheckBridge(bridge, vFpppp, cb, 0, NULL);
     if(api==my_mainloop_orig) api=my_mainloop_ref;    // need emulated version
-    return (void*)RunFunction(my_context, (uintptr_t)my_mainloop_ref->time_new, 4, api, tv, b, data);
+    return (void*)RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->time_new, "pppp", api, tv, b, data);
 }
 static void my_time_restart(void* e, void* tv)
 {
@@ -891,7 +891,7 @@ static void my_time_restart(void* e, void* tv)
     if(fnc)
         return ((vFpp_t)fnc)(e, tv);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->time_restart, 2, e, tv);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->time_restart, "pp", e, tv);
 }
 static void my_time_free(void* e)
 {
@@ -900,7 +900,7 @@ static void my_time_free(void* e)
     if(fnc)
         return ((vFp_t)fnc)(e);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->time_free, 1, e);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->time_free, "p", e);
 }
 static void my_time_set_destroy(void* e, void* cb)
 {
@@ -913,7 +913,7 @@ static void my_time_set_destroy(void* e, void* cb)
     uintptr_t b = 0;
     if(cb)
             b = AddCheckBridge(bridge, vFppp, cb, 0, NULL);
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->time_set_destroy, 2, e, b);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->time_set_destroy, "pp", e, b);
 }
 
 static void* my_defer_new(void* api, void* cb, void* data)
@@ -942,7 +942,7 @@ static void* my_defer_new(void* api, void* cb, void* data)
             b = AddBridge(bridge, vFppp, cb, 0, NULL);
     }
     if(api==my_mainloop_orig) api=my_mainloop_ref;    // need emulated version
-    return (void*)RunFunction(my_context, (uintptr_t)my_mainloop_ref->defer_new, 3, api, b, data);
+    return (void*)RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->defer_new, "ppp", api, b, data);
 }
 static void my_defer_enable(void* e, int b)
 {
@@ -951,7 +951,7 @@ static void my_defer_enable(void* e, int b)
     if(fnc)
         return ((vFpi_t)fnc)(e, b);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->defer_enable, 2, e, b);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->defer_enable, "pi", e, b);
 }
 static void my_defer_free(void* e)
 {
@@ -960,7 +960,7 @@ static void my_defer_free(void* e)
     if(fnc)
         return ((vFp_t)fnc)(e);
 
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->defer_free, 1, e);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->defer_free, "p", e);
 }
 static void my_defer_set_destroy(void* e, void* cb)
 {
@@ -973,7 +973,7 @@ static void my_defer_set_destroy(void* e, void* cb)
     uintptr_t b = 0;
     if(cb)
         b = AddCheckBridge(bridge, vFppp, cb, 0, NULL);
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->defer_set_destroy, 2, e, b);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->defer_set_destroy, "pp", e, b);
 }
 
 static void my_quit(void* api, int retval)
@@ -986,7 +986,7 @@ static void my_quit(void* api, int retval)
     }
 
     if(api==my_mainloop_orig) api=my_mainloop_ref;    // need emulated version
-    RunFunction(my_context, (uintptr_t)my_mainloop_ref->quit, 2, api, retval);
+    RunFunctionFmt(my_context, (uintptr_t)my_mainloop_ref->quit, "pi", api, retval);
 }
 
 static void bridgeMainloopAPI(bridge_t* bridge, my_pa_mainloop_api_t* api)
diff --git a/src/wrapped/wrappedsdl1.c b/src/wrapped/wrappedsdl1.c
index 4ebfb31e..9750ba4b 100755
--- a/src/wrapped/wrappedsdl1.c
+++ b/src/wrapped/wrappedsdl1.c
@@ -73,7 +73,7 @@ GO(4)
 static uintptr_t my_AudioCallback_fct_##A = 0;                                      \
 static void my_AudioCallback_##A(void *userdata, uint8_t *stream, int32_t len)      \
 {                                                                                   \
-    RunFunction(my_context, my_AudioCallback_fct_##A, 3, userdata, stream, len);    \
+    RunFunctionFmt(my_context, my_AudioCallback_fct_##A, "pCi", userdata, stream, len);    \
 }
 SUPER()
 #undef GO
@@ -95,7 +95,7 @@ static void* find_AudioCallback_Fct(void* fct)
 static uintptr_t my_TimerCallback_fct_##A = 0;                                                  \
 static uint32_t my_TimerCallback_##A(uint32_t interval, void *userdata)                         \
 {                                                                                               \
-    return (uint32_t)RunFunction(my_context, my_TimerCallback_fct_##A, 2, interval, userdata);  \
+    return (uint32_t)RunFunctionFmt(my_context, my_TimerCallback_fct_##A, "up", interval, userdata);  \
 }
 SUPER()
 #undef GO
@@ -117,7 +117,7 @@ static void* find_TimerCallback_Fct(void* fct)
 static uintptr_t my_EvtFilter_fct_##A = 0;                      \
 static int my_EvtFilter_##A(void* p)                            \
 {                                                               \
-    return RunFunction(my_context, my_EvtFilter_fct_##A, 1, p); \
+    return RunFunctionFmt(my_context, my_EvtFilter_fct_##A, "p", p); \
 }
 SUPER()
 #undef GO
@@ -350,7 +350,7 @@ EXPORT void my_SDL_KillThread(x64emu_t* emu, void* p)
     my->SDL_KillThread(p);
 }
 
-EXPORT void* my_SDL_GL_GetProcAddress(x64emu_t* emu, void* name) 
+EXPORT void* my_SDL_GL_GetProcAddress(x64emu_t* emu, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
diff --git a/src/wrapped/wrappedsdl1image.c b/src/wrapped/wrappedsdl1image.c
index 66eda2c8..ad405d90 100755
--- a/src/wrapped/wrappedsdl1image.c
+++ b/src/wrapped/wrappedsdl1image.c
@@ -24,7 +24,7 @@ const char* sdl1imageName = "libSDL_image-1.2.so.0";
 
 #include "wrappercallback.h"
 
-#define GO(A) \
+#define GO(A)   \
 void EXPORT *my_##A(x64emu_t* emu, void* a) \
 { \
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a); \
diff --git a/src/wrapped/wrappedsdl1mixer.c b/src/wrapped/wrappedsdl1mixer.c
index 9538aacf..5e9415fb 100755
--- a/src/wrapped/wrappedsdl1mixer.c
+++ b/src/wrapped/wrappedsdl1mixer.c
@@ -37,7 +37,7 @@ GO(4)
 static uintptr_t my_EffectFunc_fct_##A = 0;                                         \
 static void my_EffectFunc_##A(int chan, void *stream, int len, void *udata)         \
 {                                                                                   \
-    RunFunction(my_context, my_EffectFunc_fct_##A, 4, chan, stream, len, udata);    \
+    RunFunctionFmt(my_context, my_EffectFunc_fct_##A, "ipip", chan, stream, len, udata);    \
 }
 SUPER()
 #undef GO
@@ -61,7 +61,7 @@ static void* find_EffectFunc_Fct(void* fct)
 static uintptr_t my_EffectDone_fct_##A = 0;                         \
 static void my_EffectDone_##A(int chan, void *udata)                \
 {                                                                   \
-    RunFunction(my_context, my_EffectDone_fct_##A, 2, chan, udata); \
+    RunFunctionFmt(my_context, my_EffectDone_fct_##A, "ip", chan, udata); \
 }
 SUPER()
 #undef GO
@@ -85,7 +85,7 @@ static void* find_EffectDone_Fct(void* fct)
 static uintptr_t my_MixFunc_fct_##A = 0;                                \
 static void my_MixFunc_##A(void *udata, uint8_t *stream, int len)       \
 {                                                                       \
-    RunFunction(my_context, my_MixFunc_fct_##A, 3, udata, stream, len); \
+    RunFunctionFmt(my_context, my_MixFunc_fct_##A, "ppi", udata, stream, len); \
 }
 SUPER()
 #undef GO
@@ -109,7 +109,7 @@ static void* find_MixFunc_Fct(void* fct)
 static uintptr_t my_ChannelFinished_fct_##A = 0;                        \
 static void my_ChannelFinished_##A(int channel)                         \
 {                                                                       \
-    RunFunction(my_context, my_ChannelFinished_fct_##A, 1, channel);    \
+    RunFunctionFmt(my_context, my_ChannelFinished_fct_##A, "i", channel);    \
 }
 SUPER()
 #undef GO
@@ -133,7 +133,7 @@ static void* find_ChannelFinished_Fct(void* fct)
 static uintptr_t my_MusicFinished_fct_##A = 0;              \
 static void my_MusicFinished_##A()                          \
 {                                                           \
-    RunFunction(my_context, my_MusicFinished_fct_##A, 0);   \
+    RunFunctionFmt(my_context, my_MusicFinished_fct_##A, "");   \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedsdl2.c b/src/wrapped/wrappedsdl2.c
index 2e665e9f..8c0b03bf 100755
--- a/src/wrapped/wrappedsdl2.c
+++ b/src/wrapped/wrappedsdl2.c
@@ -104,7 +104,7 @@ GO(4)
 static uintptr_t my_Timer_fct_##A = 0;                                      \
 static uint64_t my_Timer_##A(uint64_t a, void* b)                           \
 {                                                                           \
-    return (uint64_t)RunFunction(my_context, my_Timer_fct_##A, 2, a, b);    \
+    return (uint64_t)RunFunctionFmt(my_context, my_Timer_fct_##A, "Up", a, b);    \
 }
 SUPER()
 #undef GO
@@ -121,14 +121,14 @@ static void* find_Timer_Fct(void* fct)
     #undef GO
     printf_log(LOG_NONE, "Warning, no more slot for SDL2 Timer callback\n");
     return NULL;
-    
+
 }
 // AudioCallback
 #define GO(A)   \
 static uintptr_t my_AudioCallback_fct_##A = 0;                      \
 static void my_AudioCallback_##A(void* a, void* b, int c)           \
 {                                                                   \
-    RunFunction(my_context, my_AudioCallback_fct_##A, 3, a, b, c);  \
+    RunFunctionFmt(my_context, my_AudioCallback_fct_##A, "ppi", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -145,14 +145,14 @@ static void* find_AudioCallback_Fct(void* fct)
     #undef GO
     printf_log(LOG_NONE, "Warning, no more slot for SDL2 AudioCallback callback\n");
     return NULL;
-    
+
 }
 // eventfilter
 #define GO(A)   \
 static uintptr_t my_eventfilter_fct_##A = 0;                                \
 static int my_eventfilter_##A(void* userdata, void* event)                  \
 {                                                                           \
-    return (int)RunFunction(my_context, my_eventfilter_fct_##A, 2, userdata, event);    \
+    return (int)RunFunctionFmt(my_context, my_eventfilter_fct_##A, "pp", userdata, event);    \
 }
 SUPER()
 #undef GO
@@ -169,7 +169,7 @@ static void* find_eventfilter_Fct(void* fct)
     #undef GO
     printf_log(LOG_NONE, "Warning, no more slot for SDL2 eventfilter callback\n");
     return NULL;
-    
+
 }
 static void* reverse_eventfilter_Fct(void* fct)
 {
@@ -187,7 +187,7 @@ static void* reverse_eventfilter_Fct(void* fct)
 static uintptr_t my_LogOutput_fct_##A = 0;                                  \
 static void my_LogOutput_##A(void* a, int b, int c, void* d)                \
 {                                                                           \
-    RunFunction(my_context, my_LogOutput_fct_##A, 4, a, b, c, d);  \
+    RunFunctionFmt(my_context, my_LogOutput_fct_##A, "piip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -552,7 +552,7 @@ static int get_sdl_priv(x64emu_t* emu, const char *sym_str, void **w, void **f)
         }
     #define GOS(sym, _w) GOM(sym, _w)
     #define DATA
-    
+
     if(0);
     #include "wrappedsdl2_private.h"
 
@@ -570,7 +570,7 @@ int EXPORT my2_SDL_DYNAPI_entry(x64emu_t* emu, uint32_t version, uintptr_t *tabl
     uintptr_t tab[tablesize];
     int r = my->SDL_DYNAPI_entry(version, tab, tablesize);
     (void)r;
-    
+
     #define SDL_DYNAPI_PROC(ret, sym, args, parms, ...) \
         if (i < tablesize) { \
             void *w = NULL; \
@@ -646,7 +646,7 @@ EXPORT void my2_SDL_Log(x64emu_t* emu, void* fmt, void *b) {
     my->SDL_LogMessageV(0, 3, fmt, VARARGS);
 }
 
-EXPORT void* my2_SDL_GL_GetProcAddress(x64emu_t* emu, void* name) 
+EXPORT void* my2_SDL_GL_GetProcAddress(x64emu_t* emu, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
@@ -667,7 +667,7 @@ static uintptr_t dtor_emu[nb_once] = {0};
 static void tls_dtor_callback(int n, void* a)
 {
 	if(dtor_emu[n]) {
-        RunFunction(my_context, dtor_emu[n], 1, a);
+        RunFunctionFmt(my_context, dtor_emu[n], "p", a);
 	}
 }
 #define GO(N) \
diff --git a/src/wrapped/wrappedsdl2image.c b/src/wrapped/wrappedsdl2image.c
index de520daa..290d3155 100755
--- a/src/wrapped/wrappedsdl2image.c
+++ b/src/wrapped/wrappedsdl2image.c
@@ -24,7 +24,7 @@ const char* sdl2imageName = "libSDL2_image-2.0.so.0";
 
 #include "wrappercallback.h"
 
-#define GO(A) \
+#define GO(A)   \
 EXPORT void *my2_##A(x64emu_t* emu, void* a) \
 { \
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a); \
diff --git a/src/wrapped/wrappedsdl2mixer.c b/src/wrapped/wrappedsdl2mixer.c
index 8bf9c4df..73ab0bf9 100755
--- a/src/wrapped/wrappedsdl2mixer.c
+++ b/src/wrapped/wrappedsdl2mixer.c
@@ -42,7 +42,7 @@ GO(4)
 static uintptr_t my_EffectFunc_fct_##A = 0;                                         \
 static void my_EffectFunc_##A(int chan, void *stream, int len, void *udata)         \
 {                                                                                   \
-    RunFunction(my_context, my_EffectFunc_fct_##A, 4, chan, stream, len, udata);    \
+    RunFunctionFmt(my_context, my_EffectFunc_fct_##A, "ipip", chan, stream, len, udata);    \
 }
 SUPER()
 #undef GO
@@ -66,7 +66,7 @@ static void* find_EffectFunc_Fct(void* fct)
 static uintptr_t my_EffectDone_fct_##A = 0;                         \
 static void my_EffectDone_##A(int chan, void *udata)                \
 {                                                                   \
-    RunFunction(my_context, my_EffectDone_fct_##A, 2, chan, udata); \
+    RunFunctionFmt(my_context, my_EffectDone_fct_##A, "ip", chan, udata); \
 }
 SUPER()
 #undef GO
@@ -90,7 +90,7 @@ static void* find_EffectDone_Fct(void* fct)
 static uintptr_t my_MixFunc_fct_##A = 0;                                \
 static void my_MixFunc_##A(void *udata, uint8_t *stream, int len)       \
 {                                                                       \
-    RunFunction(my_context, my_MixFunc_fct_##A, 3, udata, stream, len); \
+    RunFunctionFmt(my_context, my_MixFunc_fct_##A, "ppi", udata, stream, len); \
 }
 SUPER()
 #undef GO
@@ -114,7 +114,7 @@ static void* find_MixFunc_Fct(void* fct)
 static uintptr_t my_ChannelFinished_fct_##A = 0;                        \
 static void my_ChannelFinished_##A(int channel)                         \
 {                                                                       \
-    RunFunction(my_context, my_ChannelFinished_fct_##A, 1, channel);    \
+    RunFunctionFmt(my_context, my_ChannelFinished_fct_##A, "i", channel);    \
 }
 SUPER()
 #undef GO
@@ -138,7 +138,7 @@ static void* find_ChannelFinished_Fct(void* fct)
 static uintptr_t my_MusicFinished_fct_##A = 0;              \
 static void my_MusicFinished_##A()                          \
 {                                                           \
-    RunFunction(my_context, my_MusicFinished_fct_##A, 0);   \
+    RunFunctionFmt(my_context, my_MusicFinished_fct_##A, "");   \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedsmime3.c b/src/wrapped/wrappedsmime3.c
index 136e5510..0b4171a5 100755
--- a/src/wrapped/wrappedsmime3.c
+++ b/src/wrapped/wrappedsmime3.c
@@ -39,7 +39,7 @@ GO(4)
 static uintptr_t my_SECKEYGetPasswordKey_fct_##A = 0;                               \
 static void* my_SECKEYGetPasswordKey_##A(void* a, void* b)                          \
 {                                                                                   \
-    return (void*)RunFunction(my_context, my_SECKEYGetPasswordKey_fct_##A, 2, a, b);\
+    return (void*)RunFunctionFmt(my_context, my_SECKEYGetPasswordKey_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -62,7 +62,7 @@ static void* find_SECKEYGetPasswordKey_Fct(void* fct)
 static uintptr_t my_digestOpenFn_fct_##A = 0;                           \
 static int my_digestOpenFn_##A(void* a, int b)                          \
 {                                                                       \
-    return RunFunction(my_context, my_digestOpenFn_fct_##A, 2, a, b);   \
+    return RunFunctionFmt(my_context, my_digestOpenFn_fct_##A, "pi", a, b);   \
 }
 SUPER()
 #undef GO
@@ -85,7 +85,7 @@ static void* find_digestOpenFn_Fct(void* fct)
 static uintptr_t my_digestCloseFn_fct_##A = 0;                          \
 static int my_digestCloseFn_##A(void* a, int b)                         \
 {                                                                       \
-    return RunFunction(my_context, my_digestCloseFn_fct_##A, 2, a, b);  \
+    return RunFunctionFmt(my_context, my_digestCloseFn_fct_##A, "pi", a, b);  \
 }
 SUPER()
 #undef GO
@@ -108,7 +108,7 @@ static void* find_digestCloseFn_Fct(void* fct)
 static uintptr_t my_digestIOFn_fct_##A = 0;                             \
 static int my_digestIOFn_##A(void* a, void* b, unsigned long c)         \
 {                                                                       \
-    return RunFunction(my_context, my_digestIOFn_fct_##A, 3, a, b, c);  \
+    return RunFunctionFmt(my_context, my_digestIOFn_fct_##A, "ppL", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -131,7 +131,7 @@ static void* find_digestIOFn_Fct(void* fct)
 static uintptr_t my_SEC_PKCS12NicknameCollisionCallback_fct_##A = 0;                                    \
 static void* my_SEC_PKCS12NicknameCollisionCallback_##A(void* a, void* b, void* c)                      \
 {                                                                                                       \
-    return (void*)RunFunction(my_context, my_SEC_PKCS12NicknameCollisionCallback_fct_##A, 3, a, b, c);  \
+    return (void*)RunFunctionFmt(my_context, my_SEC_PKCS12NicknameCollisionCallback_fct_##A, "ppp", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -151,10 +151,10 @@ static void* find_SEC_PKCS12NicknameCollisionCallback_Fct(void* fct)
 
 // SEC_PKCS12EncoderOutputCallback ...
 #define GO(A)   \
-static uintptr_t my_SEC_PKCS12EncoderOutputCallback_fct_##A = 0;                        \
-static void my_SEC_PKCS12EncoderOutputCallback_##A(void* a, void* b, unsigned long c)   \
-{                                                                                       \
-    RunFunction(my_context, my_SEC_PKCS12EncoderOutputCallback_fct_##A, 3, a, b, c);    \
+static uintptr_t my_SEC_PKCS12EncoderOutputCallback_fct_##A = 0;                            \
+static void my_SEC_PKCS12EncoderOutputCallback_##A(void* a, void* b, unsigned long c)       \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_SEC_PKCS12EncoderOutputCallback_fct_##A, "ppL", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -177,7 +177,7 @@ static void* find_SEC_PKCS12EncoderOutputCallback_Fct(void* fct)
 static uintptr_t my_NSSCMSContentCallback_fct_##A = 0;                      \
 static void my_NSSCMSContentCallback_##A(void* a, void* b, unsigned long c) \
 {                                                                           \
-    RunFunction(my_context, my_NSSCMSContentCallback_fct_##A, 3, a, b, c);  \
+    RunFunctionFmt(my_context, my_NSSCMSContentCallback_fct_##A, "ppL", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -200,7 +200,7 @@ static void* find_NSSCMSContentCallback_Fct(void* fct)
 static uintptr_t my_PK11PasswordFunc_fct_##A = 0;                                   \
 static void* my_PK11PasswordFunc_##A(void* a, int b, void* c)                       \
 {                                                                                   \
-    return (void*)RunFunction(my_context, my_PK11PasswordFunc_fct_##A, 3, a, b, c); \
+    return (void*)RunFunctionFmt(my_context, my_PK11PasswordFunc_fct_##A, "pip", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -223,7 +223,7 @@ static void* find_PK11PasswordFunc_Fct(void* fct)
 static uintptr_t my_NSSCMSGetDecryptKeyCallback_fct_##A = 0;                                \
 static void* my_NSSCMSGetDecryptKeyCallback_##A(void* a, void* b)                           \
 {                                                                                           \
-    return (void*)RunFunction(my_context, my_NSSCMSGetDecryptKeyCallback_fct_##A, 2, a, b); \
+    return (void*)RunFunctionFmt(my_context, my_NSSCMSGetDecryptKeyCallback_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -246,7 +246,7 @@ static void* find_NSSCMSGetDecryptKeyCallback_Fct(void* fct)
 static uintptr_t my_CERTImportCertificateFunc_fct_##A = 0;                                  \
 static int my_CERTImportCertificateFunc_##A(void* a, void* b, int c)                        \
 {                                                                                           \
-    return (int)RunFunction(my_context, my_CERTImportCertificateFunc_fct_##A, 2, a, b, c);  \
+    return (int)RunFunctionFmt(my_context, my_CERTImportCertificateFunc_fct_##A, "ppi", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -271,7 +271,7 @@ EXPORT void my_SEC_PKCS12CreateExportContext(x64emu_t* emu, void* f, void* pwfna
     my->SEC_PKCS12CreateExportContext(find_SECKEYGetPasswordKey_Fct(f), pwfnarg, slot, wincx);
 }
 
-EXPORT void* my_SEC_PKCS12DecoderStart(x64emu_t* emu, void* item, void* slot, void* wincx, void* dOpen, void* dClose, 
+EXPORT void* my_SEC_PKCS12DecoderStart(x64emu_t* emu, void* item, void* slot, void* wincx, void* dOpen, void* dClose,
     void* dRead, void* dWrite, void* dArg)
 {
     return my->SEC_PKCS12DecoderStart(item, slot, wincx, find_digestOpenFn_Fct(dOpen), find_digestCloseFn_Fct(dClose),
diff --git a/src/wrapped/wrappedsmpeg.c b/src/wrapped/wrappedsmpeg.c
index cc552ba5..a9b2adca 100755
--- a/src/wrapped/wrappedsmpeg.c
+++ b/src/wrapped/wrappedsmpeg.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_dispcallback_fct_##A = 0;                                                   \
 static void my_dispcallback_##A(void* dst, int32_t x, int32_t y, unsigned int w, unsigned int h)\
 {                                                                                               \
-    RunFunction(my_context, my_dispcallback_fct_##A, 5, dst, x, y, w, h);                       \
+    RunFunctionFmt(my_context, my_dispcallback_fct_##A, "piiuu", dst, x, y, w, h);                       \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedsmpeg2.c b/src/wrapped/wrappedsmpeg2.c
index c95f0bab..e9ae86cf 100755
--- a/src/wrapped/wrappedsmpeg2.c
+++ b/src/wrapped/wrappedsmpeg2.c
@@ -38,7 +38,7 @@ GO(4)
 static uintptr_t my_dispcallback_fct_##A = 0;                           \
 static void my_dispcallback_##A(void* data, void* frame)                \
 {                                                                       \
-    RunFunction(my_context, my_dispcallback_fct_##A, 2, data, frame);   \
+    RunFunctionFmt(my_context, my_dispcallback_fct_##A, "pp", data, frame);   \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedvorbisfile.c b/src/wrapped/wrappedvorbisfile.c
index ad285fe7..6c2d98c9 100755
--- a/src/wrapped/wrappedvorbisfile.c
+++ b/src/wrapped/wrappedvorbisfile.c
@@ -49,9 +49,9 @@ GO(7)
 // read
 #define GO(A)   \
 static uintptr_t my_read_fct_##A = 0;   \
-static unsigned long my_read_##A(void* ptr, unsigned long size, unsigned long nmemb, void* datasource)     \
+static unsigned long my_read_##A(void* ptr, unsigned long size, unsigned long nmemb, void* datasource)  \
 {                                       \
-    return RunFunction(my_context, my_read_fct_##A, 4, ptr, size, nmemb, datasource);\
+    return RunFunctionFmt(my_context, my_read_fct_##A, "pLLp", ptr, size, nmemb, datasource);   \
 }
 SUPER()
 #undef GO
@@ -73,7 +73,7 @@ static void* findreadFct(void* fct)
 static uintptr_t my_seek_fct_##A = 0;   \
 static int my_seek_##A(void* ptr, int64_t offset, int whence)     \
 {                                       \
-    return (int)RunFunction(my_context, my_seek_fct_##A, 3, ptr, offset, whence);\
+    return (int)RunFunctionFmt(my_context, my_seek_fct_##A, "pIi", ptr, offset, whence);\
 }
 SUPER()
 #undef GO
@@ -95,7 +95,7 @@ static void* findseekFct(void* fct)
 static uintptr_t my_close_fct_##A = 0;   \
 static int my_close_##A(void* ptr)     \
 {                   \
-    return (int)RunFunction(my_context, my_close_fct_##A, 1, ptr);\
+    return (int)RunFunctionFmt(my_context, my_close_fct_##A, "p", ptr);\
 }
 SUPER()
 #undef GO
@@ -117,7 +117,7 @@ static void* findcloseFct(void* fct)
 static uintptr_t my_tell_fct_##A = 0;   \
 static long my_tell_##A(void* ptr)     \
 {                                       \
-    return (long)RunFunction(my_context, my_tell_fct_##A, 1, ptr);\
+    return (long)RunFunctionFmt(my_context, my_tell_fct_##A, "p", ptr);\
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedvulkan.c b/src/wrapped/wrappedvulkan.c
index b90747c4..b138ad9b 100755
--- a/src/wrapped/wrappedvulkan.c
+++ b/src/wrapped/wrappedvulkan.c
@@ -53,7 +53,7 @@ static void* resolveSymbol(x64emu_t* emu, void* symbol, const char* rname)
         printf_dlsym(LOG_DEBUG, "%p\n", (void*)ret);
         return (void*)ret; // already bridged
     }
-    // get wrapper    
+    // get wrapper
     khint_t k = kh_get(symbolmap, emu->context->vkwrappers, rname);
     if(k==kh_end(emu->context->vkwrappers) && strstr(rname, "KHR")==NULL) {
         // try again, adding KHR at the end if not present
@@ -74,7 +74,7 @@ static void* resolveSymbol(x64emu_t* emu, void* symbol, const char* rname)
     return (void*)ret;
 }
 
-EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name) 
+EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
@@ -95,7 +95,7 @@ EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
         #define GO(A, W) if(!strcmp(rname, #A)) my->A = (W)my->vkGetDeviceProcAddr(device, name);
         SUPER()
         #undef GO
-    } else 
+    } else
         symbol = my->vkGetDeviceProcAddr(device, name);
     if(!symbol) {
         printf_dlsym(LOG_DEBUG, "%p\n", NULL);
@@ -104,7 +104,7 @@ EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
     return resolveSymbol(emu, symbol, rname);
 }
 
-EXPORT void* my_vkGetInstanceProcAddr(x64emu_t* emu, void* instance, void* name) 
+EXPORT void* my_vkGetInstanceProcAddr(x64emu_t* emu, void* instance, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
@@ -192,10 +192,10 @@ GO(4)
 
 // Allocation ...
 #define GO(A)   \
-static uintptr_t my_Allocation_fct_##A = 0;                                         \
-static void* my_Allocation_##A(void* a, size_t b, size_t c, int d)                  \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_Allocation_fct_##A, 4, a, b, c, d);    \
+static uintptr_t my_Allocation_fct_##A = 0;                                             \
+static void* my_Allocation_##A(void* a, size_t b, size_t c, int d)                      \
+{                                                                                       \
+    return (void*)RunFunctionFmt(my_context, my_Allocation_fct_##A, "pLLi", a, b, c, d);\
 }
 SUPER()
 #undef GO
@@ -214,10 +214,10 @@ static void* find_Allocation_Fct(void* fct)
 }
 // Reallocation ...
 #define GO(A)   \
-static uintptr_t my_Reallocation_fct_##A = 0;                                           \
-static void* my_Reallocation_##A(void* a, void* b, size_t c, size_t d, int e)           \
-{                                                                                       \
-    return (void*)RunFunction(my_context, my_Reallocation_fct_##A, 5, a, b, c, d, e);   \
+static uintptr_t my_Reallocation_fct_##A = 0;                                                   \
+static void* my_Reallocation_##A(void* a, void* b, size_t c, size_t d, int e)                   \
+{                                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_Reallocation_fct_##A, "ppLLi", a, b, c, d, e);  \
 }
 SUPER()
 #undef GO
@@ -239,7 +239,7 @@ static void* find_Reallocation_Fct(void* fct)
 static uintptr_t my_Free_fct_##A = 0;                       \
 static void my_Free_##A(void* a, void* b)                   \
 {                                                           \
-    RunFunction(my_context, my_Free_fct_##A, 2, a, b);      \
+    RunFunctionFmt(my_context, my_Free_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -258,10 +258,10 @@ static void* find_Free_Fct(void* fct)
 }
 // InternalAllocNotification ...
 #define GO(A)   \
-static uintptr_t my_InternalAllocNotification_fct_##A = 0;                          \
-static void my_InternalAllocNotification_##A(void* a, size_t b, int c, int d)       \
-{                                                                                   \
-    RunFunction(my_context, my_InternalAllocNotification_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_InternalAllocNotification_fct_##A = 0;                                  \
+static void my_InternalAllocNotification_##A(void* a, size_t b, int c, int d)               \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_InternalAllocNotification_fct_##A, "pLii", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -280,10 +280,10 @@ static void* find_InternalAllocNotification_Fct(void* fct)
 }
 // InternalFreeNotification ...
 #define GO(A)   \
-static uintptr_t my_InternalFreeNotification_fct_##A = 0;                           \
-static void my_InternalFreeNotification_##A(void* a, size_t b, int c, int d)        \
-{                                                                                   \
-    RunFunction(my_context, my_InternalFreeNotification_fct_##A, 4, a, b, c, d);    \
+static uintptr_t my_InternalFreeNotification_fct_##A = 0;                                   \
+static void my_InternalFreeNotification_##A(void* a, size_t b, int c, int d)                \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_InternalFreeNotification_fct_##A, "pLii", a, b, c, d);    \
 }
 SUPER()
 #undef GO
@@ -302,10 +302,10 @@ static void* find_InternalFreeNotification_Fct(void* fct)
 }
 // DebugReportCallbackEXT ...
 #define GO(A)   \
-static uintptr_t my_DebugReportCallbackEXT_fct_##A = 0;                                                                             \
-static int my_DebugReportCallbackEXT_##A(int a, int b, uint64_t c, size_t d, int e, void* f, void* g, void* h)                      \
-{                                                                                                                                   \
-    return RunFunction(my_context, my_DebugReportCallbackEXT_fct_##A, 8, a, b, c, d, e, f, g, h);    \
+static uintptr_t my_DebugReportCallbackEXT_fct_##A = 0;                                                         \
+static int my_DebugReportCallbackEXT_##A(int a, int b, uint64_t c, size_t d, int e, void* f, void* g, void* h)  \
+{                                                                                                               \
+    return RunFunctionFmt(my_context, my_DebugReportCallbackEXT_fct_##A, "iiULippp", a, b, c, d, e, f, g, h);   \
 }
 SUPER()
 #undef GO
@@ -618,7 +618,7 @@ EXPORT void my_vkGetPhysicalDeviceMemoryProperties(x64emu_t* emu, void* device,
     my->vkGetPhysicalDeviceMemoryProperties(device, pProps);
 }
 
-EXPORT void my_vkCmdPipelineBarrier(x64emu_t* emu, void* device, int src, int dst, int dep, 
+EXPORT void my_vkCmdPipelineBarrier(x64emu_t* emu, void* device, int src, int dst, int dep,
     uint32_t barrierCount, void* pBarriers, uint32_t bufferCount, void* pBuffers, uint32_t imageCount, void* pImages)
 {
     my->vkCmdPipelineBarrier(device, src, dst, dep, barrierCount, pBarriers, bufferCount, pBuffers, imageCount, pImages);
@@ -632,12 +632,12 @@ typedef struct my_VkDebugReportCallbackCreateInfoEXT_s {
     void*       pUserData;
 } my_VkDebugReportCallbackCreateInfoEXT_t;
 
-EXPORT int my_vkCreateDebugReportCallbackEXT(x64emu_t* emu, void* instance, 
-                                             my_VkDebugReportCallbackCreateInfoEXT_t* create, 
+EXPORT int my_vkCreateDebugReportCallbackEXT(x64emu_t* emu, void* instance,
+                                             my_VkDebugReportCallbackCreateInfoEXT_t* create,
                                              my_VkAllocationCallbacks_t* alloc, void* callback)
 {
     my_VkDebugReportCallbackCreateInfoEXT_t dbg = *create;
-    my_VkAllocationCallbacks_t my_alloc; 
+    my_VkAllocationCallbacks_t my_alloc;
     dbg.pfnCallback = find_DebugReportCallbackEXT_Fct(dbg.pfnCallback);
     return my->vkCreateDebugReportCallbackEXT(instance, &dbg, find_VkAllocationCallbacks(&my_alloc, alloc), callback);
 }
@@ -648,4 +648,4 @@ EXPORT int my_vkDestroyDebugReportCallbackEXT(x64emu_t* emu, void* instance, voi
     return my->vkDestroyDebugReportCallbackEXT(instance, callback, find_VkAllocationCallbacks(&my_alloc, alloc));
 }
 
-CREATE(vkCreateHeadlessSurfaceEXT)
\ No newline at end of file
+CREATE(vkCreateHeadlessSurfaceEXT)
diff --git a/src/wrapped/wrappedxml2.c b/src/wrapped/wrappedxml2.c
index e9f8dff8..ef5f6b48 100755
--- a/src/wrapped/wrappedxml2.c
+++ b/src/wrapped/wrappedxml2.c
@@ -36,7 +36,7 @@ EXPORT uintptr_t my_xmlMemStrdup = 0;
 void my_wrap_xmlFree(void* p)
 {
     if(my_xmlFree){
-        RunFunction(my_context, my_xmlFree, 1, p);
+        RunFunctionFmt(my_context, my_xmlFree, "p", p);
         return;
     }
         free(p);
@@ -44,21 +44,21 @@ void my_wrap_xmlFree(void* p)
 void* my_wrap_xmlMalloc(size_t s)
 {
     if(my_xmlMalloc)
-        return (void*)RunFunction(my_context, my_xmlMalloc, 1, s);
+        return (void*)RunFunctionFmt(my_context, my_xmlMalloc, "L", s);
     else
         return malloc(s);
 }
 void* my_wrap_xmlRealloc(void* p, size_t s)
 {
     if(my_xmlRealloc)
-        return (void*)RunFunction(my_context, my_xmlRealloc, 2, p, s);
+        return (void*)RunFunctionFmt(my_context, my_xmlRealloc, "pL", p, s);
     else
         return realloc(p, s);
 }
 void* my_wrap_xmlMemStrdup(void* p)
 {
     if(my_xmlMemStrdup)
-        return (void*)RunFunction(my_context, my_xmlMemStrdup, 1, p);
+        return (void*)RunFunctionFmt(my_context, my_xmlMemStrdup, "p", p);
     else
         return strdup(p);
 }
@@ -98,10 +98,10 @@ GO(9)
 
 // xmlHashCopier ...
 #define GO(A)   \
-static uintptr_t my_xmlHashCopier_fct_##A = 0;                                  \
-static void* my_xmlHashCopier_##A(void* a, void* b)                             \
-{                                                                               \
-    return (void*)RunFunction(my_context, my_xmlHashCopier_fct_##A, 2, a, b);   \
+static uintptr_t my_xmlHashCopier_fct_##A = 0;                                      \
+static void* my_xmlHashCopier_##A(void* a, void* b)                                 \
+{                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_xmlHashCopier_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -120,10 +120,10 @@ static void* find_xmlHashCopier_Fct(void* fct)
 }
 // xmlHashDeallocator ...
 #define GO(A)   \
-static uintptr_t my_xmlHashDeallocator_fct_##A = 0;                     \
-static void my_xmlHashDeallocator_##A(void* a, void* b)                 \
-{                                                                       \
-    RunFunction(my_context, my_xmlHashDeallocator_fct_##A, 2, a, b);    \
+static uintptr_t my_xmlHashDeallocator_fct_##A = 0;                         \
+static void my_xmlHashDeallocator_##A(void* a, void* b)                     \
+{                                                                           \
+    RunFunctionFmt(my_context, my_xmlHashDeallocator_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -142,10 +142,10 @@ static void* find_xmlHashDeallocator_Fct(void* fct)
 }
 // xmlHashScanner ...
 #define GO(A)   \
-static uintptr_t my_xmlHashScanner_fct_##A = 0;                     \
-static void my_xmlHashScanner_##A(void* a, void* b, void* c)        \
-{                                                                   \
-    RunFunction(my_context, my_xmlHashScanner_fct_##A, 3, a, b, c); \
+static uintptr_t my_xmlHashScanner_fct_##A = 0;                             \
+static void my_xmlHashScanner_##A(void* a, void* b, void* c)                \
+{                                                                           \
+    RunFunctionFmt(my_context, my_xmlHashScanner_fct_##A, "ppp", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -164,10 +164,10 @@ static void* find_xmlHashScanner_Fct(void* fct)
 }
 // xmlHashScannerFull ...
 #define GO(A)   \
-static uintptr_t my_xmlHashScannerFull_fct_##A = 0;                                 \
-static void my_xmlHashScannerFull_##A(void* a, void* b, void* c, void* c2, void* c3)\
-{                                                                                   \
-    RunFunction(my_context, my_xmlHashScannerFull_fct_##A, 5, a, b, c, c2, c3);     \
+static uintptr_t my_xmlHashScannerFull_fct_##A = 0;                                     \
+static void my_xmlHashScannerFull_##A(void* a, void* b, void* c, void* c2, void* c3)    \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_xmlHashScannerFull_fct_##A, "ppppp", a, b, c, c2, c3);\
 }
 SUPER()
 #undef GO
@@ -186,10 +186,10 @@ static void* find_xmlHashScannerFull_Fct(void* fct)
 }
 // xmlCharEncodingInputFunc ...
 #define GO(A)   \
-static uintptr_t my_xmlCharEncodingInputFunc_fct_##A = 0;                               \
-static int my_xmlCharEncodingInputFunc_##A(void* a, void* b, void* c, void* d)          \
-{                                                                                       \
-    return RunFunction(my_context, my_xmlCharEncodingInputFunc_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_xmlCharEncodingInputFunc_fct_##A = 0;                                       \
+static int my_xmlCharEncodingInputFunc_##A(void* a, void* b, void* c, void* d)                  \
+{                                                                                               \
+    return RunFunctionFmt(my_context, my_xmlCharEncodingInputFunc_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -208,10 +208,10 @@ static void* find_xmlCharEncodingInputFunc_Fct(void* fct)
 }
 // xmlCharEncodingOutputFunc ...
 #define GO(A)   \
-static uintptr_t my_xmlCharEncodingOutputFunc_fct_##A = 0;                              \
-static int my_xmlCharEncodingOutputFunc_##A(void* a, void* b, void* c, void* d)         \
-{                                                                                       \
-    return RunFunction(my_context, my_xmlCharEncodingOutputFunc_fct_##A, 4, a, b, c, d);\
+static uintptr_t my_xmlCharEncodingOutputFunc_fct_##A = 0;                                      \
+static int my_xmlCharEncodingOutputFunc_##A(void* a, void* b, void* c, void* d)                 \
+{                                                                                               \
+    return RunFunctionFmt(my_context, my_xmlCharEncodingOutputFunc_fct_##A, "pppp", a, b, c, d);\
 }
 SUPER()
 #undef GO
@@ -230,10 +230,10 @@ static void* find_xmlCharEncodingOutputFunc_Fct(void* fct)
 }
 // xmlOutputWriteCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlOutputWriteCallback_fct_##A = 0;                             \
-static int my_xmlOutputWriteCallback_##A(void* a, void* b, int c)                   \
-{                                                                                   \
-    return RunFunction(my_context, my_xmlOutputWriteCallback_fct_##A, 3, a, b, c);  \
+static uintptr_t my_xmlOutputWriteCallback_fct_##A = 0;                                     \
+static int my_xmlOutputWriteCallback_##A(void* a, void* b, int c)                           \
+{                                                                                           \
+    return RunFunctionFmt(my_context, my_xmlOutputWriteCallback_fct_##A, "ppi", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -252,10 +252,10 @@ static void* find_xmlOutputWriteCallback_Fct(void* fct)
 }
 // xmlOutputCloseCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlOutputCloseCallback_fct_##A = 0;                         \
-static int my_xmlOutputCloseCallback_##A(void* a)                               \
-{                                                                               \
-    return RunFunction(my_context, my_xmlOutputCloseCallback_fct_##A, 1, a);    \
+static uintptr_t my_xmlOutputCloseCallback_fct_##A = 0;                             \
+static int my_xmlOutputCloseCallback_##A(void* a)                                   \
+{                                                                                   \
+    return RunFunctionFmt(my_context, my_xmlOutputCloseCallback_fct_##A, "p", a);   \
 }
 SUPER()
 #undef GO
@@ -274,10 +274,10 @@ static void* find_xmlOutputCloseCallback_Fct(void* fct)
 }
 // xmlInputMatchCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlInputMatchCallback_fct_##A = 0;                      \
-static int my_xmlInputMatchCallback_##A(void* a)                            \
-{                                                                           \
-    return RunFunction(my_context, my_xmlInputMatchCallback_fct_##A, 1, a); \
+static uintptr_t my_xmlInputMatchCallback_fct_##A = 0;                          \
+static int my_xmlInputMatchCallback_##A(void* a)                                \
+{                                                                               \
+    return RunFunctionFmt(my_context, my_xmlInputMatchCallback_fct_##A, "p", a);\
 }
 SUPER()
 #undef GO
@@ -296,10 +296,10 @@ static void* find_xmlInputMatchCallback_Fct(void* fct)
 }
 // xmlInputOpenCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlInputOpenCallback_fct_##A = 0;                               \
-static void* my_xmlInputOpenCallback_##A(void* a)                                   \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_xmlInputOpenCallback_fct_##A, 1, a);   \
+static uintptr_t my_xmlInputOpenCallback_fct_##A = 0;                                   \
+static void* my_xmlInputOpenCallback_##A(void* a)                                       \
+{                                                                                       \
+    return (void*)RunFunctionFmt(my_context, my_xmlInputOpenCallback_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -318,10 +318,10 @@ static void* find_xmlInputOpenCallback_Fct(void* fct)
 }
 // xmlInputReadCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlInputReadCallback_fct_##A = 0;                               \
-static int my_xmlInputReadCallback_##A(void* a, void* b, int c)                     \
-{                                                                                   \
-    return RunFunction(my_context, my_xmlInputReadCallback_fct_##A, 3, a, b, c);    \
+static uintptr_t my_xmlInputReadCallback_fct_##A = 0;                                   \
+static int my_xmlInputReadCallback_##A(void* a, void* b, int c)                         \
+{                                                                                       \
+    return RunFunctionFmt(my_context, my_xmlInputReadCallback_fct_##A, "ppi", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -340,10 +340,10 @@ static void* find_xmlInputReadCallback_Fct(void* fct)
 }
 // xmlInputCloseCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlInputCloseCallback_fct_##A = 0;                         \
-static int my_xmlInputCloseCallback_##A(void* a)                               \
-{                                                                               \
-    return RunFunction(my_context, my_xmlInputCloseCallback_fct_##A, 1, a);    \
+static uintptr_t my_xmlInputCloseCallback_fct_##A = 0;                              \
+static int my_xmlInputCloseCallback_##A(void* a)                                    \
+{                                                                                   \
+    return RunFunctionFmt(my_context, my_xmlInputCloseCallback_fct_##A, "p", a);    \
 }
 SUPER()
 #undef GO
@@ -365,7 +365,7 @@ static void* find_xmlInputCloseCallback_Fct(void* fct)
 static uintptr_t my_xmlSchemaValidityErrorFunc_fct_##A = 0;                                                                     \
 static void my_xmlSchemaValidityErrorFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i)  \
 {                                                                                                                               \
-    RunFunction(my_context, my_xmlSchemaValidityErrorFunc_fct_##A, 9, a, b, c, d, e, f, g, h, i);                               \
+    RunFunctionFmt(my_context, my_xmlSchemaValidityErrorFunc_fct_##A, "ppppppppp", a, b, c, d, e, f, g, h, i);                  \
 }
 SUPER()
 #undef GO
@@ -387,7 +387,7 @@ static void* find_xmlSchemaValidityErrorFunc_Fct(void* fct)
 static uintptr_t my_xmlSchemaValidityWarningFunc_fct_##A = 0;                                                                       \
 static void my_xmlSchemaValidityWarningFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i)    \
 {                                                                                                                                   \
-    RunFunction(my_context, my_xmlSchemaValidityWarningFunc_fct_##A, 9, a, b, c, d, e, f, g, h, i);                                 \
+    RunFunctionFmt(my_context, my_xmlSchemaValidityWarningFunc_fct_##A, "ppppppppp", a, b, c, d, e, f, g, h, i);                    \
 }
 SUPER()
 #undef GO
@@ -406,10 +406,10 @@ static void* find_xmlSchemaValidityWarningFunc_Fct(void* fct)
 }
 // xmlXPathFunction ...
 #define GO(A)   \
-static uintptr_t my_xmlXPathFunction_fct_##A = 0;                   \
-static void my_xmlXPathFunction_##A(void* a, int b)                 \
-{                                                                   \
-    RunFunction(my_context, my_xmlXPathFunction_fct_##A, 2, a, b);  \
+static uintptr_t my_xmlXPathFunction_fct_##A = 0;                       \
+static void my_xmlXPathFunction_##A(void* a, int b)                     \
+{                                                                       \
+    RunFunctionFmt(my_context, my_xmlXPathFunction_fct_##A, "pi", a, b);\
 }
 SUPER()
 #undef GO
@@ -428,10 +428,10 @@ static void* find_xmlXPathFunction_Fct(void* fct)
 }
 // internalSubsetSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_internalSubsetSAXFunc_fct_##A = 0;                          \
-static void my_internalSubsetSAXFunc_##A(void* a, void* b, void* c, void* d)    \
-{                                                                               \
-    RunFunction(my_context, my_internalSubsetSAXFunc_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_internalSubsetSAXFunc_fct_##A = 0;                                  \
+static void my_internalSubsetSAXFunc_##A(void* a, void* b, void* c, void* d)            \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_internalSubsetSAXFunc_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -450,10 +450,10 @@ static void* find_internalSubsetSAXFunc_Fct(void* fct)
 }
 // isStandaloneSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_isStandaloneSAXFunc_fct_##A = 0;                        \
-static int my_isStandaloneSAXFunc_##A(void* a)                              \
-{                                                                           \
-    return RunFunction(my_context, my_isStandaloneSAXFunc_fct_##A, 1, a);   \
+static uintptr_t my_isStandaloneSAXFunc_fct_##A = 0;                            \
+static int my_isStandaloneSAXFunc_##A(void* a)                                  \
+{                                                                               \
+    return RunFunctionFmt(my_context, my_isStandaloneSAXFunc_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -472,10 +472,10 @@ static void* find_isStandaloneSAXFunc_Fct(void* fct)
 }
 // hasInternalSubsetSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_hasInternalSubsetSAXFunc_fct_##A = 0;                       \
-static int my_hasInternalSubsetSAXFunc_##A(void* a)                             \
-{                                                                               \
-    return RunFunction(my_context, my_hasInternalSubsetSAXFunc_fct_##A, 1, a);  \
+static uintptr_t my_hasInternalSubsetSAXFunc_fct_##A = 0;                           \
+static int my_hasInternalSubsetSAXFunc_##A(void* a)                                 \
+{                                                                                   \
+    return RunFunctionFmt(my_context, my_hasInternalSubsetSAXFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -494,10 +494,10 @@ static void* find_hasInternalSubsetSAXFunc_Fct(void* fct)
 }
 // hasExternalSubsetSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_hasExternalSubsetSAXFunc_fct_##A = 0;                       \
-static int my_hasExternalSubsetSAXFunc_##A(void* a)                             \
-{                                                                               \
-    return RunFunction(my_context, my_hasExternalSubsetSAXFunc_fct_##A, 1, a);  \
+static uintptr_t my_hasExternalSubsetSAXFunc_fct_##A = 0;                           \
+static int my_hasExternalSubsetSAXFunc_##A(void* a)                                 \
+{                                                                                   \
+    return RunFunctionFmt(my_context, my_hasExternalSubsetSAXFunc_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -516,10 +516,10 @@ static void* find_hasExternalSubsetSAXFunc_Fct(void* fct)
 }
 // resolveEntitySAXFunc ...
 #define GO(A)   \
-static uintptr_t my_resolveEntitySAXFunc_fct_##A = 0;                                   \
-static void* my_resolveEntitySAXFunc_##A(void* a, void* b, void* c)                     \
-{                                                                                       \
-    return (void*)RunFunction(my_context, my_resolveEntitySAXFunc_fct_##A, 3, a, b, c); \
+static uintptr_t my_resolveEntitySAXFunc_fct_##A = 0;                                           \
+static void* my_resolveEntitySAXFunc_##A(void* a, void* b, void* c)                             \
+{                                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_resolveEntitySAXFunc_fct_##A, "ppp", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -538,10 +538,10 @@ static void* find_resolveEntitySAXFunc_Fct(void* fct)
 }
 // getEntitySAXFunc ...
 #define GO(A)   \
-static uintptr_t my_getEntitySAXFunc_fct_##A = 0;                                   \
-static void* my_getEntitySAXFunc_##A(void* a, void* b)                              \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_getEntitySAXFunc_fct_##A, 2, a, b);    \
+static uintptr_t my_getEntitySAXFunc_fct_##A = 0;                                       \
+static void* my_getEntitySAXFunc_##A(void* a, void* b)                                  \
+{                                                                                       \
+    return (void*)RunFunctionFmt(my_context, my_getEntitySAXFunc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -560,10 +560,10 @@ static void* find_getEntitySAXFunc_Fct(void* fct)
 }
 // entityDeclSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_entityDeclSAXFunc_fct_##A = 0;                                      \
-static void my_entityDeclSAXFunc_##A(void* a, void* b, int c, void* d, void* e, void* f)\
-{                                                                                       \
-    RunFunction(my_context, my_entityDeclSAXFunc_fct_##A, 6, a, b, c, d, e, f);         \
+static uintptr_t my_entityDeclSAXFunc_fct_##A = 0;                                          \
+static void my_entityDeclSAXFunc_##A(void* a, void* b, int c, void* d, void* e, void* f)    \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_entityDeclSAXFunc_fct_##A, "ppippp", a, b, c, d, e, f);   \
 }
 SUPER()
 #undef GO
@@ -582,10 +582,10 @@ static void* find_entityDeclSAXFunc_Fct(void* fct)
 }
 // notationDeclSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_notationDeclSAXFunc_fct_##A = 0;                        \
-static void my_notationDeclSAXFunc_##A(void* a, void* b, void* c, void* d)  \
-{                                                                           \
-    RunFunction(my_context, my_notationDeclSAXFunc_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_notationDeclSAXFunc_fct_##A = 0;                                \
+static void my_notationDeclSAXFunc_##A(void* a, void* b, void* c, void* d)          \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_notationDeclSAXFunc_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -607,7 +607,7 @@ static void* find_notationDeclSAXFunc_Fct(void* fct)
 static uintptr_t my_attributeDeclSAXFunc_fct_##A = 0;                                               \
 static void my_attributeDeclSAXFunc_##A(void* a, void* b, void* c, int d, int e, void* f, void* g)  \
 {                                                                                                   \
-    RunFunction(my_context, my_attributeDeclSAXFunc_fct_##A, 7, a, b, c, d, e, f, g);               \
+    RunFunctionFmt(my_context, my_attributeDeclSAXFunc_fct_##A, "pppiipp", a, b, c, d, e, f, g);    \
 }
 SUPER()
 #undef GO
@@ -626,10 +626,10 @@ static void* find_attributeDeclSAXFunc_Fct(void* fct)
 }
 // elementDeclSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_elementDeclSAXFunc_fct_##A = 0;                         \
-static void my_elementDeclSAXFunc_##A(void* a, void* b, int c, void* d)     \
-{                                                                           \
-    RunFunction(my_context, my_elementDeclSAXFunc_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_elementDeclSAXFunc_fct_##A = 0;                                 \
+static void my_elementDeclSAXFunc_##A(void* a, void* b, int c, void* d)             \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_elementDeclSAXFunc_fct_##A, "ppip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
@@ -648,10 +648,10 @@ static void* find_elementDeclSAXFunc_Fct(void* fct)
 }
 // unparsedEntityDeclSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_unparsedEntityDeclSAXFunc_fct_##A = 0;                                  \
-static void my_unparsedEntityDeclSAXFunc_##A(void* a, void* b, void* c, void* d, void* e)   \
-{                                                                                           \
-    RunFunction(my_context, my_unparsedEntityDeclSAXFunc_fct_##A, 5, a, b, c, d, e);        \
+static uintptr_t my_unparsedEntityDeclSAXFunc_fct_##A = 0;                                      \
+static void my_unparsedEntityDeclSAXFunc_##A(void* a, void* b, void* c, void* d, void* e)       \
+{                                                                                               \
+    RunFunctionFmt(my_context, my_unparsedEntityDeclSAXFunc_fct_##A, "ppppp", a, b, c, d, e);   \
 }
 SUPER()
 #undef GO
@@ -670,10 +670,10 @@ static void* find_unparsedEntityDeclSAXFunc_Fct(void* fct)
 }
 // setDocumentLocatorSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_setDocumentLocatorSAXFunc_fct_##A = 0;                  \
-static void my_setDocumentLocatorSAXFunc_##A(void* a, void* b)              \
-{                                                                           \
-    RunFunction(my_context, my_setDocumentLocatorSAXFunc_fct_##A, 2, a, b); \
+static uintptr_t my_setDocumentLocatorSAXFunc_fct_##A = 0;                      \
+static void my_setDocumentLocatorSAXFunc_##A(void* a, void* b)                  \
+{                                                                               \
+    RunFunctionFmt(my_context, my_setDocumentLocatorSAXFunc_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -692,10 +692,10 @@ static void* find_setDocumentLocatorSAXFunc_Fct(void* fct)
 }
 // startDocumentSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_startDocumentSAXFunc_fct_##A = 0;               \
-static void my_startDocumentSAXFunc_##A(void* a)                    \
-{                                                                   \
-    RunFunction(my_context, my_startDocumentSAXFunc_fct_##A, 1, a); \
+static uintptr_t my_startDocumentSAXFunc_fct_##A = 0;                   \
+static void my_startDocumentSAXFunc_##A(void* a)                        \
+{                                                                       \
+    RunFunctionFmt(my_context, my_startDocumentSAXFunc_fct_##A, "p", a);\
 }
 SUPER()
 #undef GO
@@ -714,10 +714,10 @@ static void* find_startDocumentSAXFunc_Fct(void* fct)
 }
 // endDocumentSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_endDocumentSAXFunc_fct_##A = 0;               \
-static void my_endDocumentSAXFunc_##A(void* a)                    \
-{                                                                   \
-    RunFunction(my_context, my_endDocumentSAXFunc_fct_##A, 1, a); \
+static uintptr_t my_endDocumentSAXFunc_fct_##A = 0;                     \
+static void my_endDocumentSAXFunc_##A(void* a)                          \
+{                                                                       \
+    RunFunctionFmt(my_context, my_endDocumentSAXFunc_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -736,10 +736,10 @@ static void* find_endDocumentSAXFunc_Fct(void* fct)
 }
 // startElementSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_startElementSAXFunc_fct_##A = 0;                        \
-static void my_startElementSAXFunc_##A(void* a, void* b, void* c)           \
-{                                                                           \
-    RunFunction(my_context, my_startElementSAXFunc_fct_##A, 3, a, b, c);    \
+static uintptr_t my_startElementSAXFunc_fct_##A = 0;                            \
+static void my_startElementSAXFunc_##A(void* a, void* b, void* c)               \
+{                                                                               \
+    RunFunctionFmt(my_context, my_startElementSAXFunc_fct_##A, "ppp", a, b, c); \
 }
 SUPER()
 #undef GO
@@ -758,10 +758,10 @@ static void* find_startElementSAXFunc_Fct(void* fct)
 }
 // endElementSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_endElementSAXFunc_fct_##A = 0;                  \
-static void my_endElementSAXFunc_##A(void* a, void* b)              \
-{                                                                   \
-    RunFunction(my_context, my_endElementSAXFunc_fct_##A, 2, a, b); \
+static uintptr_t my_endElementSAXFunc_fct_##A = 0;                          \
+static void my_endElementSAXFunc_##A(void* a, void* b)                      \
+{                                                                           \
+    RunFunctionFmt(my_context, my_endElementSAXFunc_fct_##A, "pp", a, b);   \
 }
 SUPER()
 #undef GO
@@ -780,10 +780,10 @@ static void* find_endElementSAXFunc_Fct(void* fct)
 }
 // referenceSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_referenceSAXFunc_fct_##A = 0;                  \
-static void my_referenceSAXFunc_##A(void* a, void* b)              \
-{                                                                   \
-    RunFunction(my_context, my_referenceSAXFunc_fct_##A, 2, a, b); \
+static uintptr_t my_referenceSAXFunc_fct_##A = 0;                       \
+static void my_referenceSAXFunc_##A(void* a, void* b)                   \
+{                                                                       \
+    RunFunctionFmt(my_context, my_referenceSAXFunc_fct_##A, "pp", a, b);\
 }
 SUPER()
 #undef GO
@@ -802,10 +802,10 @@ static void* find_referenceSAXFunc_Fct(void* fct)
 }
 // charactersSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_charactersSAXFunc_fct_##A = 0;                      \
-static void my_charactersSAXFunc_##A(void* a, void* b, int c)           \
-{                                                                       \
-    RunFunction(my_context, my_charactersSAXFunc_fct_##A, 3, a, b, c);  \
+static uintptr_t my_charactersSAXFunc_fct_##A = 0;                              \
+static void my_charactersSAXFunc_##A(void* a, void* b, int c)                   \
+{                                                                               \
+    RunFunctionFmt(my_context, my_charactersSAXFunc_fct_##A, "ppi", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -824,10 +824,10 @@ static void* find_charactersSAXFunc_Fct(void* fct)
 }
 // ignorableWhitespaceSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_ignorableWhitespaceSAXFunc_fct_##A = 0;                      \
-static void my_ignorableWhitespaceSAXFunc_##A(void* a, void* b, int c)           \
-{                                                                       \
-    RunFunction(my_context, my_ignorableWhitespaceSAXFunc_fct_##A, 3, a, b, c);  \
+static uintptr_t my_ignorableWhitespaceSAXFunc_fct_##A = 0;                             \
+static void my_ignorableWhitespaceSAXFunc_##A(void* a, void* b, int c)                  \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_ignorableWhitespaceSAXFunc_fct_##A, "ppi", a, b, c);  \
 }
 SUPER()
 #undef GO
@@ -846,10 +846,10 @@ static void* find_ignorableWhitespaceSAXFunc_Fct(void* fct)
 }
 // processingInstructionSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_processingInstructionSAXFunc_fct_##A = 0;                       \
-static void my_processingInstructionSAXFunc_##A(void* a, void* b, void* c)          \
-{                                                                                   \
-    RunFunction(my_context, my_processingInstructionSAXFunc_fct_##A, 3, a, b, c);   \
+static uintptr_t my_processingInstructionSAXFunc_fct_##A = 0;                               \
+static void my_processingInstructionSAXFunc_##A(void* a, void* b, void* c)                  \
+{                                                                                           \
+    RunFunctionFmt(my_context, my_processingInstructionSAXFunc_fct_##A, "ppp", a, b, c);    \
 }
 SUPER()
 #undef GO
@@ -868,10 +868,10 @@ static void* find_processingInstructionSAXFunc_Fct(void* fct)
 }
 // commentSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_commentSAXFunc_fct_##A = 0;                     \
-static void my_commentSAXFunc_##A(void* a, void* b)                 \
-{                                                                   \
-    RunFunction(my_context, my_commentSAXFunc_fct_##A, 2, a, b);    \
+static uintptr_t my_commentSAXFunc_fct_##A = 0;                         \
+static void my_commentSAXFunc_##A(void* a, void* b)                     \
+{                                                                       \
+    RunFunctionFmt(my_context, my_commentSAXFunc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -890,10 +890,10 @@ static void* find_commentSAXFunc_Fct(void* fct)
 }
 // warningSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_warningSAXFunc_fct_##A = 0;                     \
-static void my_warningSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j)\
-{                                                                   \
-    RunFunction(my_context, my_warningSAXFunc_fct_##A, 10, a, b, c, d, e, f, g, h, i, j);    \
+static uintptr_t my_warningSAXFunc_fct_##A = 0; \
+static void my_warningSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j) \
+{   \
+    RunFunctionFmt(my_context, my_warningSAXFunc_fct_##A, "pppppppppp", a, b, c, d, e, f, g, h, i, j);  \
 }
 SUPER()
 #undef GO
@@ -912,10 +912,10 @@ static void* find_warningSAXFunc_Fct(void* fct) // this one have a VAArg
 }
 // errorSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_errorSAXFunc_fct_##A = 0;                     \
-static void my_errorSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j)\
-{                                                                   \
-    RunFunction(my_context, my_errorSAXFunc_fct_##A, 10, a, b, c, d, e, f, g, h, i, j);    \
+static uintptr_t my_errorSAXFunc_fct_##A = 0;   \
+static void my_errorSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j)   \
+{   \
+    RunFunctionFmt(my_context, my_errorSAXFunc_fct_##A, "pppppppppp", a, b, c, d, e, f, g, h, i, j);    \
 }
 SUPER()
 #undef GO
@@ -934,10 +934,10 @@ static void* find_errorSAXFunc_Fct(void* fct) // this one have a VAArg
 }
 // fatalErrorSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_fatalErrorSAXFunc_fct_##A = 0;                     \
-static void my_fatalErrorSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j)\
-{                                                                   \
-    RunFunction(my_context, my_fatalErrorSAXFunc_fct_##A, 10, a, b, c, d, e, f, g, h, i, j);    \
+static uintptr_t my_fatalErrorSAXFunc_fct_##A = 0;  \
+static void my_fatalErrorSAXFunc_##A(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j)  \
+{   \
+    RunFunctionFmt(my_context, my_fatalErrorSAXFunc_fct_##A, "pppppppppp", a, b, c, d, e, f, g, h, i, j);   \
 }
 SUPER()
 #undef GO
@@ -956,10 +956,10 @@ static void* find_fatalErrorSAXFunc_Fct(void* fct) // this one have a VAArg
 }
 // getParameterEntitySAXFunc ...
 #define GO(A)   \
-static uintptr_t my_getParameterEntitySAXFunc_fct_##A = 0;                                  \
-static void* my_getParameterEntitySAXFunc_##A(void* a, void* b)                             \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_getParameterEntitySAXFunc_fct_##A, 2, a, b);   \
+static uintptr_t my_getParameterEntitySAXFunc_fct_##A = 0;                                      \
+static void* my_getParameterEntitySAXFunc_##A(void* a, void* b)                                 \
+{                                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_getParameterEntitySAXFunc_fct_##A, "pp", a, b); \
 }
 SUPER()
 #undef GO
@@ -978,10 +978,10 @@ static void* find_getParameterEntitySAXFunc_Fct(void* fct) // this one have a VA
 }
 // cdataBlockSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_cdataBlockSAXFunc_fct_##A = 0;                      \
-static void my_cdataBlockSAXFunc_##A(void* a, void* b, int c)           \
-{                                                                       \
-    RunFunction(my_context, my_cdataBlockSAXFunc_fct_##A, 3, a, b, c);  \
+static uintptr_t my_cdataBlockSAXFunc_fct_##A = 0;                              \
+static void my_cdataBlockSAXFunc_##A(void* a, void* b, int c)                   \
+{                                                                               \
+    RunFunctionFmt(my_context, my_cdataBlockSAXFunc_fct_##A, "ppi", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1000,10 +1000,10 @@ static void* find_cdataBlockSAXFunc_Fct(void* fct) // this one have a VAArg
 }
 // externalSubsetSAXFunc ...
 #define GO(A)   \
-static uintptr_t my_externalSubsetSAXFunc_fct_##A = 0;                          \
-static void my_externalSubsetSAXFunc_##A(void* a, void* b, void* c, void* d)    \
-{                                                                               \
-    RunFunction(my_context, my_externalSubsetSAXFunc_fct_##A, 4, a, b, c, d);   \
+static uintptr_t my_externalSubsetSAXFunc_fct_##A = 0;                                  \
+static void my_externalSubsetSAXFunc_##A(void* a, void* b, void* c, void* d)            \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_externalSubsetSAXFunc_fct_##A, "pppp", a, b, c, d);   \
 }
 SUPER()
 #undef GO
@@ -1025,7 +1025,7 @@ static void* find_externalSubsetSAXFunc_Fct(void* fct) // this one have a VAArg
 static uintptr_t my_xmlSAX2StartElementNs_fct_##A = 0;                                                              \
 static void my_xmlSAX2StartElementNs_##A(void* a, void* b, void* c, void* d, int e, void* f, int g, int h, void* i) \
 {                                                                                                                   \
-    RunFunction(my_context, my_xmlSAX2StartElementNs_fct_##A, 9, a, b, c, d, e, f, g, h, i);                        \
+    RunFunctionFmt(my_context, my_xmlSAX2StartElementNs_fct_##A, "ppppipiip", a, b, c, d, e, f, g, h, i);           \
 }
 SUPER()
 #undef GO
@@ -1044,10 +1044,10 @@ static void* find_xmlSAX2StartElementNs_Fct(void* fct) // this one have a VAArg
 }
 // xmlSAX2EndElementNs ...
 #define GO(A)   \
-static uintptr_t my_xmlSAX2EndElementNs_fct_##A = 0;                        \
-static void my_xmlSAX2EndElementNs_##A(void* a, void* b, void* c, void* d)  \
-{                                                                           \
-    RunFunction(my_context, my_xmlSAX2EndElementNs_fct_##A, 4, a, b, c, d); \
+static uintptr_t my_xmlSAX2EndElementNs_fct_##A = 0;                                \
+static void my_xmlSAX2EndElementNs_##A(void* a, void* b, void* c, void* d)          \
+{                                                                                   \
+    RunFunctionFmt(my_context, my_xmlSAX2EndElementNs_fct_##A, "pppp", a, b, c, d); \
 }
 SUPER()
 #undef GO
@@ -1067,10 +1067,10 @@ static void* find_xmlSAX2EndElementNs_Fct(void* fct) // this one have a VAArg
 
 // xmlExternalEntityLoader
 #define GO(A)   \
-static uintptr_t my_xmlExternalEntityLoader_fct_##A = 0;                                    \
-static void* my_xmlExternalEntityLoader_##A(void* a, void* b, void* c)                      \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_xmlExternalEntityLoader_fct_##A, 3, a, b, c);  \
+static uintptr_t my_xmlExternalEntityLoader_fct_##A = 0;                                            \
+static void* my_xmlExternalEntityLoader_##A(void* a, void* b, void* c)                              \
+{                                                                                                   \
+    return (void*)RunFunctionFmt(my_context, my_xmlExternalEntityLoader_fct_##A, "ppp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -1101,15 +1101,15 @@ static void* reverse_xmlExternalEntityLoaderFct(void* fct)
 
 // xmlGenericErrorFunc
 #define GO(A)   \
-static uintptr_t my_xmlGenericErrorFunc_fct_##A = 0;                                    \
-static void my_xmlGenericErrorFunc_##A(void* a, const char* fmt, ...)                   \
-{                                                                                       \
-    char buf[4096];                                                                     \
-    va_list args;                                                                       \
-    va_start(args, fmt);                                                                \
-    vsnprintf(buf, 4096, fmt, args);                                                    \
-    va_end(args);                                                                       \
-    RunFunction(my_context, my_xmlGenericErrorFunc_fct_##A, 2, a, buf);                 \
+static uintptr_t my_xmlGenericErrorFunc_fct_##A = 0;                            \
+static void my_xmlGenericErrorFunc_##A(void* a, const char* fmt, ...)           \
+{                                                                               \
+    char buf[4096];                                                             \
+    va_list args;                                                               \
+    va_start(args, fmt);                                                        \
+    vsnprintf(buf, 4096, fmt, args);                                            \
+    va_end(args);                                                               \
+    RunFunctionFmt(my_context, my_xmlGenericErrorFunc_fct_##A, "pp", a, buf);   \
 }
 SUPER()
 #undef GO
@@ -1139,10 +1139,10 @@ static void* reverse_xmlGenericErrorFunc_Fct(void* fct)
 
 // xmlStructuredErrorFunc
 #define GO(A)   \
-static uintptr_t my_xmlStructuredErrorFunc_fct_##A = 0;                     \
-static void my_xmlStructuredErrorFunc_##A(void* a, const char* b)           \
-{                                                                           \
-    RunFunction(my_context, my_xmlStructuredErrorFunc_fct_##A, 2, a, b);    \
+static uintptr_t my_xmlStructuredErrorFunc_fct_##A = 0;                         \
+static void my_xmlStructuredErrorFunc_##A(void* a, const char* b)               \
+{                                                                               \
+    RunFunctionFmt(my_context, my_xmlStructuredErrorFunc_fct_##A, "pp", a, b);  \
 }
 SUPER()
 #undef GO
@@ -1172,10 +1172,10 @@ static void* reverse_xmlStructuredErrorFunc_Fct(void* fct)
 
 // xmlOutputMatchCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlOutputMatchCallback_fct_##A = 0;                             \
-static int my_xmlOutputMatchCallback_##A(void* a)                                   \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_xmlOutputMatchCallback_fct_##A, 1, a);   \
+static uintptr_t my_xmlOutputMatchCallback_fct_##A = 0;                                 \
+static int my_xmlOutputMatchCallback_##A(void* a)                                       \
+{                                                                                       \
+    return (int)RunFunctionFmt(my_context, my_xmlOutputMatchCallback_fct_##A, "p", a);  \
 }
 SUPER()
 #undef GO
@@ -1195,10 +1195,10 @@ static void* find_xmlOutputMatchCallback_Fct(void* fct) // this one have a VAArg
 
 // xmlOutputOpenCallback ...
 #define GO(A)   \
-static uintptr_t my_xmlOutputOpenCallback_fct_##A = 0;                              \
-static void* my_xmlOutputOpenCallback_##A(void* a)                                  \
-{                                                                                   \
-    return (void*)RunFunction(my_context, my_xmlOutputOpenCallback_fct_##A, 1, a);  \
+static uintptr_t my_xmlOutputOpenCallback_fct_##A = 0;                                  \
+static void* my_xmlOutputOpenCallback_##A(void* a)                                      \
+{                                                                                       \
+    return (void*)RunFunctionFmt(my_context, my_xmlOutputOpenCallback_fct_##A, "p", a); \
 }
 SUPER()
 #undef GO
@@ -1218,10 +1218,10 @@ static void* find_xmlOutputOpenCallback_Fct(void* fct) // this one have a VAArg
 
 // xmlTextReaderErrorFunc ...
 #define GO(A)   \
-static uintptr_t my_xmlTextReaderErrorFunc_fct_##A = 0;                         \
-static void my_xmlTextReaderErrorFunc_##A(void* a, void* b, int c, void* d)     \
-{                                                                               \
-    RunFunction(my_context, my_xmlTextReaderErrorFunc_fct_##A, 4, a, b, c, d);  \
+static uintptr_t my_xmlTextReaderErrorFunc_fct_##A = 0;                                 \
+static void my_xmlTextReaderErrorFunc_##A(void* a, void* b, int c, void* d)             \
+{                                                                                       \
+    RunFunctionFmt(my_context, my_xmlTextReaderErrorFunc_fct_##A, "ppip", a, b, c, d);  \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped/wrappedxslt.c b/src/wrapped/wrappedxslt.c
index 118dc5b7..07639c21 100755
--- a/src/wrapped/wrappedxslt.c
+++ b/src/wrapped/wrappedxslt.c
@@ -40,10 +40,10 @@ GO(4)
 
 // xmlXPathFunction ...
 #define GO(A)   \
-static uintptr_t my_xmlXPathFunction_fct_##A = 0;                   \
-static void my_xmlXPathFunction_##A(void* a, int b)                 \
-{                                                                   \
-    RunFunction(my_context, my_xmlXPathFunction_fct_##A, 2, a, b);  \
+static uintptr_t my_xmlXPathFunction_fct_##A = 0;                           \
+static void my_xmlXPathFunction_##A(void* a, int b)                         \
+{                                                                           \
+    RunFunctionFmt(my_context, my_xmlXPathFunction_fct_##A, "pi", a, b);    \
 }
 SUPER()
 #undef GO
@@ -62,10 +62,10 @@ static void* find_xmlXPathFunction_Fct(void* fct)
 }
 // xsltDocLoaderFunc ...
 #define GO(A)   \
-static uintptr_t my_xsltDocLoaderFunc_fct_##A = 0;                                          \
-static void* my_xsltDocLoaderFunc_##A(void* a, void* b, int c, void* d, int e)              \
-{                                                                                           \
-    return (void*)RunFunction(my_context, my_xsltDocLoaderFunc_fct_##A, 5, a, b, c, d, e);  \
+static uintptr_t my_xsltDocLoaderFunc_fct_##A = 0;                              \
+static void* my_xsltDocLoaderFunc_##A(void* a, void* b, int c, void* d, int e)  \
+{                                                                               \
+    return (void*)RunFunctionFmt(my_context, my_xsltDocLoaderFunc_fct_##A, "ppipi", a, b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -84,10 +84,10 @@ static void* find_xsltDocLoaderFunc_Fct(void* fct)
 }
 // xsltSecurityCheck ...
 #define GO(A)   \
-static uintptr_t my_xsltSecurityCheck_fct_##A = 0;                                  \
-static int my_xsltSecurityCheck_##A(void* a, void* b, void* c)                      \
-{                                                                                   \
-    return (int)RunFunction(my_context, my_xsltSecurityCheck_fct_##A, 3, a, b, c);  \
+static uintptr_t my_xsltSecurityCheck_fct_##A = 0;                                          \
+static int my_xsltSecurityCheck_##A(void* a, void* b, void* c)                              \
+{                                                                                           \
+    return (int)RunFunctionFmt(my_context, my_xsltSecurityCheck_fct_##A, "ppp", a, b, c);   \
 }
 SUPER()
 #undef GO
@@ -106,10 +106,10 @@ static void* find_xsltSecurityCheck_Fct(void* fct)
 }
 // xsltSortFunc ...
 #define GO(A)   \
-static uintptr_t my_xsltSortFunc_fct_##A = 0;                       \
-static void my_xsltSortFunc_##A(void* a, void* b, int c)            \
-{                                                                   \
-    RunFunction(my_context, my_xsltSortFunc_fct_##A, 3, a, b, c);   \
+static uintptr_t my_xsltSortFunc_fct_##A = 0;                               \
+static void my_xsltSortFunc_##A(void* a, void* b, int c)                    \
+{                                                                           \
+    RunFunctionFmt(my_context, my_xsltSortFunc_fct_##A, "ppi", a, b, c);    \
 }
 SUPER()
 #undef GO