rmagick 4.2.2 → 5.4.4

data/ext/RMagick/rmagick.h

@@ -16,14 +16,21 @@
 //! Suppress warnings about deprecated functions on Windows
 #define _CRT_SECURE_NO_DEPRECATE 1
 
-#include <assert.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <math.h>
-#include <sys/types.h>
-#include "ruby.h"
-#include "ruby/io.h"
+// ruby.h contains a C++ template, which cannot be included in extern "C".
+// Therefore, it includes the header in advance.
+#include "ruby/defines.h"
+
+extern "C" {
+    #include <assert.h>
+    #include <stdio.h>
+    #include <ctype.h>
+    #include <stdlib.h>
+    #include <math.h>
+    #include <sys/types.h>
+    #include "ruby.h"
+    #include "ruby/io.h"
+    #include "rmagick_gvl.h"
+}
 
 #if defined(__MINGW32__)
     // Ruby defines wrong format specifiers for MinGW. So this defines original macro in here.
@@ -44,10 +51,6 @@
 #endif
 
 #if defined(__GNUC__)
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
-    #pragma GCC diagnostic ignored "-Wunknown-pragmas"
-
     #if __GNUC__ > 6
         #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
     #endif
@@ -61,6 +64,11 @@
 #undef PACKAGE_TARNAME
 #undef WORDS_BIGENDIAN
 
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#undef RUBY_TYPED_FROZEN_SHAREABLE
+#define RUBY_TYPED_FROZEN_SHAREABLE 0
+#endif
+
 #include "extconf.h"
 
 #if defined(IMAGEMAGICK_7)
@@ -90,8 +98,8 @@
 
 //! Trace new image creation in bang methods
 #define UPDATE_DATA_PTR(_obj_, _new_) \
-    do { (void) rm_trace_creation(_new_);\
-    DATA_PTR(_obj_) = (void *)(_new_);\
+    do { \
+        DATA_PTR(_obj_) = (void *)(_new_); \
     } while(0)
 
 
@@ -310,7 +318,7 @@ typedef enum _QuantumExpressionOperator
 
 
 /** This implements the "omitted storage class model" for external variables.
- * (Ref: Harbison & Steele.) The rmmain.c file defines MAIN, which causes
+ * (Ref: Harbison & Steele.) The rmmain.cpp file defines MAIN, which causes
  * the single defining declarations to be generated. No other source files
  * define MAIN and therefore generate referencing declarations.
  */
@@ -396,7 +404,6 @@ EXTERN VALUE Class_KernelInfoType;
 /**
 *   Commonly-used IDs
 */
-EXTERN ID rm_ID_trace_proc;        /**< "@trace_proc" */
 EXTERN ID rm_ID_call;              /**< "call" */
 EXTERN ID rm_ID_changed;           /**< "changed" */
 EXTERN ID rm_ID_cur_image;         /**< "cur_image" */
@@ -411,7 +418,13 @@ EXTERN ID rm_ID_push;              /**< "push" */
 EXTERN ID rm_ID_values;            /**< "values" */
 EXTERN ID rm_ID_width;             /**< "width" */
 
-EXTERN unsigned long long rm_main_thread_id;
+extern const rb_data_type_t rm_enum_data_type;
+extern const rb_data_type_t rm_info_data_type;
+extern const rb_data_type_t rm_image_data_type;
+extern const rb_data_type_t rm_draw_data_type;
+extern const rb_data_type_t rm_pixel_data_type;
+extern const rb_data_type_t rm_montage_data_type;
+extern const rb_data_type_t rm_kernel_info_data_type;
 
 #if !defined(min)
 #define min(a, b) ((a)<(b)?(a):(b)) /**< min of two values */
@@ -431,59 +444,59 @@ EXTERN unsigned long long rm_main_thread_id;
     Define simple attribute accessor methods (boolean, int, string, and double types)
 */
 #define C_boolean_to_R_boolean(attr) (attr) ? Qtrue : Qfalse /**< C boolean -> Ruby boolean */
-#define R_boolean_to_C_boolean(attr) RTEST(attr) /**<  C boolean <- Ruby boolean */
+#define R_boolean_to_C_boolean(attr) (MagickBooleanType)RTEST(attr) /**<  C boolean <- Ruby boolean */
 #define C_int_to_R_int(attr) INT2FIX(attr) /**< C int -> Ruby int */
 #define R_int_to_C_int(attr) NUM2INT(attr) /**< C int <- Ruby int */
-#define C_long_to_R_long(attr) INT2NUM(attr) /**< C long -> Ruby long */
+#define C_long_to_R_long(attr) LONG2NUM(attr) /**< C long -> Ruby long */
 #define R_long_to_C_long(attr) NUM2LONG(attr) /**< C long <- Ruby long */
-#define C_ulong_to_R_ulong(attr) UINT2NUM(attr) /**< C unsigned long -> Ruby unsigned long */
+#define C_ulong_to_R_ulong(attr) ULONG2NUM(attr) /**< C unsigned long -> Ruby unsigned long */
 #define R_ulong_to_C_ulong(attr) NUM2ULONG(attr) /**< C unsigned long <- Ruby unsigned long */
 #define C_str_to_R_str(attr) attr ? rb_str_new2(attr) : Qnil /**< C string -> Ruby string */
 #define C_dbl_to_R_dbl(attr) rb_float_new(attr) /**< C double -> Ruby double */
 #define R_dbl_to_C_dbl(attr) NUM2DBL(attr) /**< C double <- Ruby double */
 
 //! define attribute reader
-#define IMPLEMENT_ATTR_READER(class, attr, type) \
+#define IMPLEMENT_TYPED_ATTR_READER(klass, attr, type, data_type) \
     {\
-        class *ptr;\
+        klass *ptr;\
         if (rb_obj_is_kind_of(self, Class_Image) == Qtrue) {\
             rm_check_destroyed(self); \
         }\
-        Data_Get_Struct(self, class, ptr);\
+        TypedData_Get_Struct(self, klass, data_type, ptr);\
         return C_##type##_to_R_##type(ptr->attr);\
     }
 
 //! define attribute reader when attribute name is different from the field name
-#define IMPLEMENT_ATTR_READERF(class, attr, field, type) \
+#define IMPLEMENT_TYPED_ATTR_READERF(klass, attr, field, type, data_type) \
     {\
-        class *ptr;\
+        klass *ptr;\
         rm_check_destroyed(self); \
-        Data_Get_Struct(self, class, ptr);\
+        TypedData_Get_Struct(self, klass, data_type, ptr);\
         return C_##type##_to_R_##type(ptr->field);\
     }
 
 //! define attribute writer
-#define IMPLEMENT_ATTR_WRITER(class, attr, type) \
+#define IMPLEMENT_TYPED_ATTR_WRITER(klass, attr, type, data_type) \
     {\
-        class *ptr;\
+        klass *ptr;\
         if (rb_obj_is_kind_of(self, Class_Image) == Qtrue) {\
             rm_check_destroyed(self); \
         }\
         rb_check_frozen(self);\
-        Data_Get_Struct(self, class, ptr);\
+        TypedData_Get_Struct(self, klass, data_type, ptr);\
         ptr->attr = R_##type##_to_C_##type(val);\
         return val;\
     }
 
 //! define attribute writer when attribute name is different from the field name
-#define IMPLEMENT_ATTR_WRITERF(class, attr, field, type) \
+#define IMPLEMENT_TYPED_ATTR_WRITERF(klass, attr, field, type, data_type) \
     {\
-        class *ptr;\
+        klass *ptr;\
         if (rb_obj_is_kind_of(self, Class_Image) == Qtrue) {\
             rm_check_destroyed(self); \
         }\
         rb_check_frozen(self);\
-        Data_Get_Struct(self, class, ptr);\
+        TypedData_Get_Struct(self, klass, data_type, ptr);\
         ptr->field = R_##type##_to_C_##type(val);\
         return self;\
     }
@@ -493,15 +506,15 @@ EXTERN unsigned long long rm_main_thread_id;
  *  Declare attribute accessors
  */
 //! declare attribute reader
-#define ATTR_READER(class, attr) \
-    extern VALUE class##_##attr(VALUE);
+#define ATTR_READER(klass, attr) \
+    extern VALUE klass##_##attr(VALUE);
 //! declare attribute writer
-#define ATTR_WRITER(class, attr) \
-    extern VALUE class##_##attr##_eq(VALUE, VALUE);
+#define ATTR_WRITER(klass, attr) \
+    extern VALUE klass##_##attr##_eq(VALUE, VALUE);
 //! declare attribute accessor
-#define ATTR_ACCESSOR(class, attr) \
-    ATTR_READER(class, attr)\
-    ATTR_WRITER(class, attr)
+#define ATTR_ACCESSOR(klass, attr) \
+    ATTR_READER(klass, attr)\
+    ATTR_WRITER(klass, attr)
 
 
 //!  Define a Magick module constant
@@ -513,7 +526,6 @@ EXTERN unsigned long long rm_main_thread_id;
 #define DEF_CONSTV(constant, val) rb_define_const(Module_Magick, #constant, UINT2NUM(val))
 #endif
 
-
 //! Convert a Ruby enum constant back to a C enum member.
 #define VALUE_TO_ENUM(value, e, type) \
    do {\
@@ -521,7 +533,7 @@ EXTERN unsigned long long rm_main_thread_id;
    if (CLASS_OF(value) != Class_##type)\
        rb_raise(rb_eTypeError, "wrong enumeration type - expected %s, got %s", \
                 rb_class2name(Class_##type), rb_class2name(CLASS_OF(value)));\
-   Data_Get_Struct(value, MagickEnum, magick_enum);\
+   TypedData_Get_Struct(value, MagickEnum, &rm_enum_data_type, magick_enum);\
    e = (type)(magick_enum->val);\
    } while(0)
 
@@ -534,11 +546,13 @@ EXTERN unsigned long long rm_main_thread_id;
 // the same source file.
 
 
-// rmmain.c
+extern "C" {
+
+// rmmain.cpp
 extern void Init_RMagick2(void);
 
 
-// rmagick.c
+// rmagick.cpp
 extern VALUE Magick_colors(VALUE);
 extern VALUE Magick_fonts(VALUE);
 extern VALUE Magick_init_formats(VALUE);
@@ -547,7 +561,7 @@ extern VALUE Magick_set_cache_threshold(VALUE, VALUE);
 extern VALUE Magick_set_log_event_mask(int, VALUE *, VALUE);
 extern VALUE Magick_set_log_format(VALUE, VALUE);
 
-// rmdraw.c
+// rmdraw.cpp
 ATTR_WRITER(Draw, affine)
 ATTR_WRITER(Draw, align)
 ATTR_WRITER(Draw, border_color)
@@ -598,7 +612,7 @@ ATTR_WRITER(PolaroidOptions, shadow_color);
 ATTR_WRITER(PolaroidOptions, border_color);
 
 
-// rmmontage.c
+// rmmontage.cpp
 ATTR_WRITER(Montage, background_color)
 ATTR_WRITER(Montage, border_color)
 ATTR_WRITER(Montage, border_width)
@@ -621,7 +635,7 @@ extern VALUE Montage_alloc(VALUE);
 extern VALUE rm_montage_new(void);
 
 
-// rmilist.c
+// rmilist.cpp
 extern VALUE ImageList_animate(int, VALUE *, VALUE);
 extern VALUE ImageList_append(VALUE, VALUE);
 extern VALUE ImageList_average(VALUE);
@@ -643,7 +657,7 @@ extern VALUE ImageList_write(VALUE, VALUE);
 extern VALUE rm_imagelist_from_images(Image *);
 
 
-// rminfo.c
+// rminfo.cpp
 ATTR_ACCESSOR(Info, antialias)
 ATTR_ACCESSOR(Info, attenuate)
 ATTR_ACCESSOR(Info, authenticate)
@@ -705,7 +719,7 @@ extern VALUE rm_info_new(void);
 extern DisposeType rm_dispose_to_enum(const char *);
 extern GravityType rm_gravity_to_enum(const char *);
 
-// rmkinfo.c
+// rmkinfo.cpp
 
 extern VALUE KernelInfo_alloc(VALUE);
 
@@ -718,7 +732,7 @@ extern VALUE KernelInfo_clone(VALUE);
 extern VALUE KernelInfo_builtin(VALUE, VALUE, VALUE);
 
 
-// rmimage.c
+// rmimage.cpp
 ATTR_ACCESSOR(Image, background_color)
 ATTR_READER(Image, base_columns)
 ATTR_READER(Image, base_filename)
@@ -1019,10 +1033,9 @@ extern VALUE Image_write(VALUE, VALUE);
 
 extern VALUE rm_image_new(Image *);
 extern void  rm_image_destroy(void *);
-extern void  rm_trace_creation(Image *);
 
 
-// rmfill.c
+// rmfill.cpp
 extern VALUE  GradientFill_alloc(VALUE);
 extern VALUE  GradientFill_initialize(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
 extern VALUE  GradientFill_fill(VALUE, VALUE);
@@ -1032,7 +1045,7 @@ extern VALUE  TextureFill_initialize(VALUE, VALUE);
 extern VALUE  TextureFill_fill(VALUE, VALUE);
 
 
-// rmpixel.c
+// rmpixel.cpp
 
 
 ATTR_ACCESSOR(Pixel, red)
@@ -1043,7 +1056,6 @@ ATTR_ACCESSOR(Pixel, cyan)
 ATTR_ACCESSOR(Pixel, magenta)
 ATTR_ACCESSOR(Pixel, yellow)
 ATTR_ACCESSOR(Pixel, black)
-extern void   destroy_Pixel(Pixel *);
 extern VALUE  Pixel_alloc(VALUE);
 extern VALUE  Pixel_case_eq(VALUE, VALUE);
 extern VALUE  Pixel_clone(VALUE);
@@ -1064,7 +1076,7 @@ extern VALUE  Pixel_to_hsla(VALUE);
 extern VALUE  Pixel_to_s(VALUE);
 
 
-// rmenum.c
+// rmenum.cpp
 extern VALUE  Enum_alloc(VALUE);
 extern VALUE  Enum_initialize(VALUE, VALUE, VALUE);
 extern VALUE  Enum_to_s(VALUE);
@@ -1073,7 +1085,7 @@ extern VALUE  Enum_spaceship(VALUE, VALUE);
 extern VALUE  Enum_bitwise_or(VALUE, VALUE);
 extern VALUE  Enum_case_eq(VALUE, VALUE);
 extern VALUE  Enum_type_initialize(VALUE, VALUE, VALUE);
-extern VALUE  Enum_find(VALUE class, int val);
+extern VALUE  Enum_find(VALUE, int);
 extern VALUE  Enum_type_each(VALUE);
 extern VALUE  rm_enum_new(VALUE, VALUE, VALUE);
 extern VALUE  ClassType_find(ClassType);
@@ -1100,7 +1112,7 @@ extern const char *StyleType_name(StyleType);
 extern VALUE  VirtualPixelMethod_find(VirtualPixelMethod);
 
 
-// rmstruct.c
+// rmstruct.cpp
 extern VALUE  ChromaticityInfo_to_s(VALUE);
 extern VALUE  ChromaticityInfo_new(ChromaticityInfo *);
 extern void   Color_to_PixelColor(PixelColor *, VALUE);
@@ -1135,7 +1147,7 @@ extern void   Export_TypeInfo(TypeInfo *, VALUE);
 extern VALUE  Import_TypeMetric(TypeMetric *);
 
 
-// rmutil.c
+// rmutil.cpp
 extern VALUE  ImageMagickError_initialize(int, VALUE *, VALUE);
 extern void  *magick_malloc(const size_t);
 extern void  *magick_safe_malloc(const size_t, const size_t);
@@ -1156,7 +1168,7 @@ extern void   rm_check_ary_len(VALUE, long);
 extern VALUE  rm_check_ary_type(VALUE ary);
 extern Image *rm_check_destroyed(VALUE);
 extern Image *rm_check_frozen(VALUE);
-extern char  *rm_str2cstr(VALUE, long *);
+extern char  *rm_str2cstr(VALUE, size_t *);
 extern int    rm_check_num2dbl(VALUE);
 extern double rm_fuzz_to_dbl(VALUE);
 extern Quantum rm_app2quantum(VALUE);
@@ -1173,6 +1185,9 @@ extern void   rm_set_user_artifact(Image *, Info *);
 extern void   rm_sync_image_options(Image *, Info *);
 extern void   rm_split(Image *);
 extern void   rm_magick_error(const char *);
+#if defined(IMAGEMAGICK_7)
+extern void   rm_set_pixelinfo_alpha(PixelInfo *, const MagickRealType);
+#endif
 
 //! whether to retain on errors
 typedef enum
@@ -1190,7 +1205,6 @@ typedef enum
 extern void   rm_check_exception(ExceptionInfo *, Image *, ErrorRetention);
 extern void   rm_ensure_result(Image *);
 extern Image *rm_clone_image(Image *);
-extern MagickBooleanType rm_progress_monitor(const char *, const MagickOffsetType, const MagickSizeType, void *);
 extern VALUE  rm_exif_by_entry(Image *);
 extern VALUE  rm_exif_by_number(Image *);
 extern void   rm_get_optional_arguments(VALUE);
@@ -1199,10 +1213,26 @@ extern void   rm_error_handler(const ExceptionType, const char *, const char *);
 extern void   rm_warning_handler(const ExceptionType, const char *, const char *);
 extern MagickBooleanType rm_should_raise_exception(ExceptionInfo *, const ExceptionRetention);
 extern void   rm_raise_exception(ExceptionInfo *);
-extern unsigned long long rm_current_thread_id();
+extern VALUE  rm_io_path(VALUE);
 #if defined(IMAGEMAGICK_6)
 extern void   rm_check_image_exception(Image *, ErrorRetention);
 #endif
 
+#if !defined(IMAGEMAGICK_GREATER_THAN_EQUAL_6_9_0)
+/* UnityAddKernelInfo() was private function until IM 6.9 */
+MagickExport void UnityAddKernelInfo(KernelInfo *kernel, const double scale);
+/* ScaleKernelInfo() was private function until IM 6.9 */
+MagickExport void ScaleKernelInfo(KernelInfo *kernel, const double scaling_factor, const GeometryFlags normalize_flags);
+#endif
+
+#if (RUBY_VERSION_MAJOR == 2 && RUBY_VERSION_MINOR < 7)
+    #define RESCUE_FUNC(func)                   (VALUE (*)(ANYARGS))(func)
+    #define RESCUE_EXCEPTION_HANDLER_FUNC(func) (VALUE (*)(ANYARGS))(func)
+#else
+    #define RESCUE_FUNC(func)                   (VALUE(*)(VALUE))(func)
+    #define RESCUE_EXCEPTION_HANDLER_FUNC(func) (VALUE(*)(VALUE, VALUE))(func)
 #endif
 
+} // extern "C"
+
+#endif

data/ext/RMagick/rmagick_gvl.h

@@ -0,0 +1,224 @@
+#ifndef _RMAGICK_GVL_H_
+#define _RMAGICK_GVL_H_
+
+#include "ruby/thread.h"
+
+typedef void *(gvl_function_t)(void *);
+
+#define GVL_FUNC(name)        name##_gvl
+#define GVL_STRUCT_TYPE(name) name##_args_t
+#define CALL_FUNC_WITHOUT_GVL(fp, args) \
+    rb_thread_call_without_gvl(fp, args, RUBY_UBF_PROCESS, NULL)
+
+
+#define DEFINE_GVL_STRUCT1(name, type1) \
+    typedef struct { \
+        type1 arg1; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC1(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1); \
+    }
+
+#define DEFINE_GVL_STUB1(name, type1) \
+    DEFINE_GVL_STRUCT1(name, type1); \
+    DEFINE_GVL_FUNC1(name, name)
+
+
+#define DEFINE_GVL_STRUCT2(name, type1, type2) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC2(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2); \
+    }
+
+#define DEFINE_GVL_STUB2(name, type1, type2) \
+    DEFINE_GVL_STRUCT2(name, type1, type2); \
+    DEFINE_GVL_FUNC2(name, name)
+
+
+#define DEFINE_GVL_STRUCT3(name, type1, type2, type3) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC3(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3); \
+    }
+
+#define DEFINE_GVL_STUB3(name, type1, type2, type3) \
+    DEFINE_GVL_STRUCT3(name, type1, type2, type3); \
+    DEFINE_GVL_FUNC3(name, name)
+
+
+#define DEFINE_GVL_STRUCT4(name, type1, type2, type3, type4) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC4(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4); \
+    }
+
+#define DEFINE_GVL_STUB4(name, type1, type2, type3, type4) \
+    DEFINE_GVL_STRUCT4(name, type1, type2, type3, type4); \
+    DEFINE_GVL_FUNC4(name, name)
+
+
+#define DEFINE_GVL_STRUCT5(name, type1, type2, type3, type4, type5) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+        type5 arg5; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC5(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5); \
+    }
+#define DEFINE_GVL_STUB5(name, type1, type2, type3, type4, type5) \
+    DEFINE_GVL_STRUCT5(name, type1, type2, type3, type4, type5); \
+    DEFINE_GVL_FUNC5(name, name)
+
+
+#define DEFINE_GVL_STRUCT6(name, type1, type2, type3, type4, type5, type6) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+        type5 arg5; \
+        type6 arg6; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC6(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6); \
+    }
+#define DEFINE_GVL_STUB6(name, type1, type2, type3, type4, type5, type6) \
+    DEFINE_GVL_STRUCT6(name, type1, type2, type3, type4, type5, type6); \
+    DEFINE_GVL_FUNC6(name, name)
+
+
+#define DEFINE_GVL_STRUCT7(name, type1, type2, type3, type4, type5, type6, type7) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+        type5 arg5; \
+        type6 arg6; \
+        type7 arg7; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC7(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6, args->arg7); \
+    }
+#define DEFINE_GVL_STUB7(name, type1, type2, type3, type4, type5, type6, type7) \
+    DEFINE_GVL_STRUCT7(name, type1, type2, type3, type4, type5, type6, type7); \
+    DEFINE_GVL_FUNC7(name, name)
+
+
+#define DEFINE_GVL_STRUCT8(name, type1, type2, type3, type4, type5, type6, type7, type8) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+        type5 arg5; \
+        type6 arg6; \
+        type7 arg7; \
+        type8 arg8; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC8(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6, args->arg7, args->arg8); \
+    }
+#define DEFINE_GVL_STUB8(name, type1, type2, type3, type4, type5, type6, type7, type8) \
+    DEFINE_GVL_STRUCT8(name, type1, type2, type3, type4, type5, type6, type7, type8); \
+    DEFINE_GVL_FUNC8(name, name)
+
+
+#define DEFINE_GVL_STRUCT9(name, type1, type2, type3, type4, type5, type6, type7, type8, type9) \
+    typedef struct { \
+        type1 arg1; \
+        type2 arg2; \
+        type3 arg3; \
+        type4 arg4; \
+        type5 arg5; \
+        type6 arg6; \
+        type7 arg7; \
+        type8 arg8; \
+        type9 arg9; \
+    } GVL_STRUCT_TYPE(name)
+#define DEFINE_GVL_FUNC9(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        return (void *)func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6, args->arg7, args->arg8, args->arg9); \
+    }
+#define DEFINE_GVL_STUB9(name, type1, type2, type3, type4, type5, type6, type7, type8, type9) \
+    DEFINE_GVL_STRUCT9(name, type1, type2, type3, type4, type5, type6, type7, type8, type9); \
+    DEFINE_GVL_FUNC9(name, name)
+
+
+#define DEFINE_GVL_VOID_FUNC2(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        func_name(args->arg1, args->arg2); \
+        return NULL; \
+    }
+#define DEFINE_GVL_VOID_STUB2(name, type1, type2) \
+    DEFINE_GVL_STRUCT2(name, type1, type2); \
+    DEFINE_GVL_VOID_FUNC2(name, name)
+
+
+#define DEFINE_GVL_VOID_FUNC3(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        func_name(args->arg1, args->arg2, args->arg3); \
+        return NULL; \
+    }
+#define DEFINE_GVL_VOID_STUB3(name, type1, type2, type3) \
+    DEFINE_GVL_STRUCT3(name, type1, type2, type3); \
+    DEFINE_GVL_VOID_FUNC3(name, name)
+
+
+#define DEFINE_GVL_VOID_FUNC6(func_name, struct_name) \
+    static void *func_name##_gvl(void *p) \
+    { \
+        GVL_STRUCT_TYPE(struct_name) *args = (GVL_STRUCT_TYPE(struct_name) *)p; \
+        func_name(args->arg1, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6); \
+        return NULL; \
+    }
+#define DEFINE_GVL_VOID_STUB6(name, type1, type2, type3, type4, type5, type6) \
+    DEFINE_GVL_STRUCT6(name, type1, type2, type3, type4, type5, type6); \
+    DEFINE_GVL_VOID_FUNC6(name, name)
+
+#endif