ffi 1.9.24 → 1.16.3

data/ext/ffi_c/Function.h

@@ -34,11 +34,7 @@
 extern "C" {
 #endif
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 
 #include <ffi.h>
 
@@ -46,7 +42,7 @@ typedef struct FunctionType_ FunctionType;
 
 #include "Type.h"
 #include "Call.h"
-#include "Closure.h"
+#include "ClosurePool.h"
 
 struct FunctionType_ {
     Type type; /* The native type of a FunctionInfo object */
@@ -60,6 +56,7 @@ struct FunctionType_ {
     ffi_type** ffiParameterTypes;
     ffi_cif ffi_cif;
     Invoker invoke;
+    ClosurePool* closurePool;
     int parameterCount;
     int flags;
     ffi_abi abi;
@@ -71,6 +68,7 @@ struct FunctionType_ {
     bool hasStruct;
 };
 
+extern const rb_data_type_t rbffi_fntype_data_type;
 extern VALUE rbffi_FunctionTypeClass, rbffi_FunctionClass;
 
 void rbffi_Function_Init(VALUE moduleFFI);

data/ext/ffi_c/FunctionInfo.c

@@ -33,12 +33,8 @@
 #include <sys/types.h>
 #include <stdio.h>
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 
 #include <errno.h>
 #include <ruby.h>
@@ -55,8 +51,24 @@
 
 static VALUE fntype_allocate(VALUE klass);
 static VALUE fntype_initialize(int argc, VALUE* argv, VALUE self);
-static void fntype_mark(FunctionType*);
-static void fntype_free(FunctionType *);
+static void fntype_mark(void *);
+static void fntype_compact(void *);
+static void fntype_free(void *);
+static size_t fntype_memsize(const void *);
+
+const rb_data_type_t rbffi_fntype_data_type = { /* extern */
+    .wrap_struct_name = "FFI::FunctionType",
+    .function = {
+        .dmark = fntype_mark,
+        .dfree = fntype_free,
+        .dsize = fntype_memsize,
+        ffi_compact_callback( fntype_compact )
+    },
+    .parent = &rbffi_type_data_type,
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
 
 VALUE rbffi_FunctionTypeClass = Qnil;
 
@@ -64,39 +76,80 @@ static VALUE
 fntype_allocate(VALUE klass)
 {
     FunctionType* fnInfo;
-    VALUE obj = Data_Make_Struct(klass, FunctionType, fntype_mark, fntype_free, fnInfo);
+    VALUE obj = TypedData_Make_Struct(klass, FunctionType, &rbffi_fntype_data_type, fnInfo);
 
     fnInfo->type.ffiType = &ffi_type_pointer;
     fnInfo->type.nativeType = NATIVE_FUNCTION;
-    fnInfo->rbReturnType = Qnil;
-    fnInfo->rbParameterTypes = Qnil;
-    fnInfo->rbEnums = Qnil;
+    RB_OBJ_WRITE(obj, &fnInfo->rbReturnType, Qnil);
+    RB_OBJ_WRITE(obj, &fnInfo->rbParameterTypes, Qnil);
+    RB_OBJ_WRITE(obj, &fnInfo->rbEnums, Qnil);
     fnInfo->invoke = rbffi_CallFunction;
+    fnInfo->closurePool = NULL;
 
     return obj;
 }
 
 static void
-fntype_mark(FunctionType* fnInfo)
+fntype_mark(void *data)
+{
+    FunctionType *fnInfo = (FunctionType *)data;
+    rb_gc_mark_movable(fnInfo->rbReturnType);
+    rb_gc_mark_movable(fnInfo->rbParameterTypes);
+    rb_gc_mark_movable(fnInfo->rbEnums);
+    if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
+        size_t index;
+        for (index = 0; index < fnInfo->callbackCount; index++) {
+            rb_gc_mark_movable(fnInfo->callbackParameters[index]);
+        }
+    }
+}
+
+static void
+fntype_compact(void *data)
 {
-    rb_gc_mark(fnInfo->rbReturnType);
-    rb_gc_mark(fnInfo->rbParameterTypes);
-    rb_gc_mark(fnInfo->rbEnums);
+    FunctionType *fnInfo = (FunctionType *)data;
+    ffi_gc_location(fnInfo->rbReturnType);
+    ffi_gc_location(fnInfo->rbParameterTypes);
+    ffi_gc_location(fnInfo->rbEnums);
     if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
-        rb_gc_mark_locations(&fnInfo->callbackParameters[0], &fnInfo->callbackParameters[fnInfo->callbackCount]);
+        size_t index;
+        for (index = 0; index < fnInfo->callbackCount; index++) {
+            ffi_gc_location(fnInfo->callbackParameters[index]);
+        }
     }
 }
 
 static void
-fntype_free(FunctionType* fnInfo)
+fntype_free(void *data)
 {
+    FunctionType *fnInfo = (FunctionType *)data;
     xfree(fnInfo->parameterTypes);
     xfree(fnInfo->ffiParameterTypes);
     xfree(fnInfo->nativeParameterTypes);
     xfree(fnInfo->callbackParameters);
+    if (fnInfo->closurePool != NULL) {
+        rbffi_ClosurePool_Free(fnInfo->closurePool);
+    }
     xfree(fnInfo);
 }
 
+static size_t
+fntype_memsize(const void *data)
+{
+    const FunctionType *fnInfo = (const FunctionType *)data;
+
+    size_t memsize = sizeof(FunctionType);
+    memsize += fnInfo->callbackCount * sizeof(VALUE);
+
+    memsize += fnInfo->parameterCount * (
+        sizeof(*fnInfo->parameterTypes)
+        + sizeof(ffi_type *)
+        + sizeof(*fnInfo->nativeParameterTypes)
+    );
+
+    return memsize;
+}
+
 /*
  * call-seq: initialize(return_type, param_types, options={})
  * @param [Type, Symbol] return_type return type for the function
@@ -129,13 +182,13 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
     Check_Type(rbParamTypes, T_ARRAY);
 
-    Data_Get_Struct(self, FunctionType, fnInfo);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, fnInfo);
     fnInfo->parameterCount = (int) RARRAY_LEN(rbParamTypes);
     fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes));
     fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *));
     fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes));
-    fnInfo->rbParameterTypes = rb_ary_new2(fnInfo->parameterCount);
-    fnInfo->rbEnums = rbEnums;
+    RB_OBJ_WRITE(self, &fnInfo->rbParameterTypes, rb_ary_new2(fnInfo->parameterCount));
+    RB_OBJ_WRITE(self, &fnInfo->rbEnums, rbEnums);
     fnInfo->blocking = RTEST(rbBlocking);
     fnInfo->hasStruct = false;
 
@@ -150,7 +203,8 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
         if (rb_obj_is_kind_of(type, rbffi_FunctionTypeClass)) {
             REALLOC_N(fnInfo->callbackParameters, VALUE, fnInfo->callbackCount + 1);
-            fnInfo->callbackParameters[fnInfo->callbackCount++] = type;
+            RB_OBJ_WRITE(self, &fnInfo->callbackParameters[fnInfo->callbackCount], type);
+            fnInfo->callbackCount++;
         }
 
         if (rb_obj_is_kind_of(type, rbffi_StructByValueClass)) {
@@ -158,25 +212,24 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
         }
 
         rb_ary_push(fnInfo->rbParameterTypes, type);
-        Data_Get_Struct(type, Type, fnInfo->parameterTypes[i]);
+        TypedData_Get_Struct(type, Type, &rbffi_type_data_type, fnInfo->parameterTypes[i]);
         fnInfo->ffiParameterTypes[i] = fnInfo->parameterTypes[i]->ffiType;
         fnInfo->nativeParameterTypes[i] = fnInfo->parameterTypes[i]->nativeType;
     }
 
-    fnInfo->rbReturnType = rbffi_Type_Lookup(rbReturnType);
+    RB_OBJ_WRITE(self, &fnInfo->rbReturnType, rbffi_Type_Lookup(rbReturnType));
     if (!RTEST(fnInfo->rbReturnType)) {
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
     }
-    
+
     if (rb_obj_is_kind_of(fnInfo->rbReturnType, rbffi_StructByValueClass)) {
         fnInfo->hasStruct = true;
     }
 
-    Data_Get_Struct(fnInfo->rbReturnType, Type, fnInfo->returnType);
+    TypedData_Get_Struct(fnInfo->rbReturnType, Type, &rbffi_type_data_type, fnInfo->returnType);
     fnInfo->ffiReturnType = fnInfo->returnType->ffiType;
 
-
 #if defined(X86_WIN32)
     rbConventionStr = (rbConvention != Qnil) ? rb_funcall2(rbConvention, rb_intern("to_s"), 0, NULL) : Qnil;
     fnInfo->abi = (rbConventionStr != Qnil && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)
@@ -200,20 +253,22 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
 
     fnInfo->invoke = rbffi_GetInvoker(fnInfo);
 
+    rb_obj_freeze(fnInfo->rbParameterTypes);
+    rb_obj_freeze(self);
     return self;
 }
 
 /*
- * call-seq: result_type
+ * call-seq: return_type
  * @return [Type]
  * Get the return type of the function type
  */
 static VALUE
-fntype_result_type(VALUE self)
+fntype_return_type(VALUE self)
 {
     FunctionType* ft;
 
-    Data_Get_Struct(self, FunctionType, ft);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
 
     return ft->rbReturnType;
 }
@@ -228,7 +283,7 @@ fntype_param_types(VALUE self)
 {
     FunctionType* ft;
 
-    Data_Get_Struct(self, FunctionType, ft);
+    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
 
     return rb_ary_dup(ft->rbParameterTypes);
 }
@@ -260,7 +315,7 @@ rbffi_FunctionInfo_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate);
     rb_define_method(rbffi_FunctionTypeClass, "initialize", fntype_initialize, -1);
-    rb_define_method(rbffi_FunctionTypeClass, "result_type", fntype_result_type, 0);
+    rb_define_method(rbffi_FunctionTypeClass, "return_type", fntype_return_type, 0);
     rb_define_method(rbffi_FunctionTypeClass, "param_types", fntype_param_types, 0);
 
 }

data/ext/ffi_c/LastError.c

@@ -33,12 +33,8 @@
 #endif
 #include <sys/types.h>
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <ruby.h>
 
@@ -49,8 +45,17 @@
 # define USE_PTHREAD_LOCAL
 #endif
 
+#if defined(__CYGWIN__)
+typedef uint32_t DWORD;
+DWORD __stdcall GetLastError(void);
+void __stdcall SetLastError(DWORD);
+#endif
+
 typedef struct ThreadData {
     int td_errno;
+#if defined(_WIN32) || defined(__CYGWIN__)
+    DWORD td_winapi_errno;
+#endif
 } ThreadData;
 
 #if defined(USE_PTHREAD_LOCAL)
@@ -86,30 +91,49 @@ thread_data_free(void *ptr)
 }
 
 #else
+static size_t
+thread_data_memsize(const void *data) {
+    return sizeof(ThreadData);
+}
+
+static const rb_data_type_t thread_data_data_type = {
+    .wrap_struct_name = "FFI::ThreadData",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = thread_data_memsize,
+    },
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static ID id_thread_data;
 
 static ThreadData*
 thread_data_init(void)
 {
-    ThreadData* td;
+    ThreadData *td;
     VALUE obj;
 
-    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
+    obj = TypedData_Make_Struct(rb_cObject, ThreadData, &thread_data_data_type, td);
     rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);
 
     return td;
 }
 
 static inline ThreadData*
-thread_data_get()
+thread_data_get(void)
 {
     VALUE obj = rb_thread_local_aref(rb_thread_current(), id_thread_data);
 
-    if (obj != Qnil && TYPE(obj) == T_DATA) {
-        return (ThreadData *) DATA_PTR(obj);
+    if (NIL_P(obj)) {
+        return thread_data_init();
     }
 
-    return thread_data_init();
+    ThreadData *td;
+    TypedData_Get_Struct(obj, ThreadData, &thread_data_data_type, td);
+    return td;
 }
 
 #endif
@@ -126,6 +150,19 @@ get_last_error(VALUE self)
     return INT2NUM(thread_data_get()->td_errno);
 }
 
+#if defined(_WIN32) || defined(__CYGWIN__)
+/*
+ * call-seq: winapi_error
+ * @return [Numeric]
+ * Get +GetLastError()+ value. Only Windows or Cygwin.
+ */
+static VALUE
+get_last_winapi_error(VALUE self)
+{
+    return INT2NUM(thread_data_get()->td_winapi_errno);
+}
+#endif
+
 
 /*
  * call-seq: error(error)
@@ -136,7 +173,6 @@ get_last_error(VALUE self)
 static VALUE
 set_last_error(VALUE self, VALUE error)
 {
-
 #ifdef _WIN32
     SetLastError(NUM2INT(error));
 #else
@@ -146,22 +182,40 @@ set_last_error(VALUE self, VALUE error)
     return Qnil;
 }
 
+#if defined(_WIN32) || defined(__CYGWIN__)
+/*
+ * call-seq: error(error)
+ * @param [Numeric] error
+ * @return [nil]
+ * Set +GetLastError()+ value. Only on Windows and Cygwin.
+ */
+static VALUE
+set_last_winapi_error(VALUE self, VALUE error)
+{
+    SetLastError(NUM2INT(error));
+    return Qnil;
+}
+#endif
+
 
 void
 rbffi_save_errno(void)
 {
     int error = 0;
-
 #ifdef _WIN32
     error = GetLastError();
 #else
     error = errno;
 #endif
 
+#if defined(_WIN32) || defined(__CYGWIN__)
+    DWORD winapi_error = GetLastError();
+    thread_data_get()->td_winapi_errno = winapi_error;
+#endif
+
     thread_data_get()->td_errno = error;
 }
 
-
 void
 rbffi_LastError_Init(VALUE moduleFFI)
 {
@@ -175,6 +229,11 @@ rbffi_LastError_Init(VALUE moduleFFI)
     rb_define_module_function(moduleError, "error", get_last_error, 0);
     rb_define_module_function(moduleError, "error=", set_last_error, 1);
 
+#if defined(_WIN32) || defined(__CYGWIN__)
+    rb_define_module_function(moduleError, "winapi_error", get_last_winapi_error, 0);
+    rb_define_module_function(moduleError, "winapi_error=", set_last_winapi_error, 1);
+#endif
+
 #if defined(USE_PTHREAD_LOCAL)
     pthread_key_create(&threadDataKey, thread_data_free);
 #else

data/ext/ffi_c/LongDouble.c

@@ -3,15 +3,15 @@
 #include <stdarg.h>
 #include <float.h>
 
-#if defined (__CYGWIN__) || defined(__INTERIX)
+#if defined (__CYGWIN__) || defined(__INTERIX) || defined(_MSC_VER)
 # define strtold(str, endptr)    ((long double) strtod((str), (endptr)))
 #endif /* defined (__CYGWIN__) */
 
 static VALUE rb_cBigDecimal = Qnil;
 static VALUE bigdecimal_load(VALUE unused);
-static VALUE bigdecimal_failed(VALUE value);
+static VALUE bigdecimal_failed(VALUE value, VALUE exc);
 
-VALUE 
+VALUE
 rbffi_longdouble_new(long double ld)
 {
     if (!RTEST(rb_cBigDecimal)) {
@@ -21,27 +21,29 @@ rbffi_longdouble_new(long double ld)
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject) {
         char buf[128];
-        return rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
+        return rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
     }
 
     /* Fall through to handling as a float */
     return rb_float_new(ld);
 }
 
-long double 
+long double
 rbffi_num2longdouble(VALUE value)
 {
     if (TYPE(value) == T_FLOAT) {
         return rb_num2dbl(value);
     }
-    
+
     if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
         rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
     }
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
         VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
-        return strtold(RSTRING_PTR(s), NULL);
+        long double ret = strtold(RSTRING_PTR(s), NULL);
+        RB_GC_GUARD(s);
+        return ret;
     }
 
     /* Fall through to handling as a float */
@@ -49,15 +51,15 @@ rbffi_num2longdouble(VALUE value)
 }
 
 
-static VALUE 
+static VALUE
 bigdecimal_load(VALUE unused)
 {
     rb_require("bigdecimal");
     return rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 }
 
-static VALUE 
-bigdecimal_failed(VALUE value)
+static VALUE
+bigdecimal_failed(VALUE value, VALUE exc)
 {
     return value;
 }

data/ext/ffi_c/LongDouble.h

@@ -36,10 +36,6 @@
 extern "C" {
 #endif
 
-#ifdef _MSC_VER
-#define strtold strtod
-#endif
-
 extern VALUE rbffi_longdouble_new(long double ld);
 extern long double rbffi_num2longdouble(VALUE value);
 

data/ext/ffi_c/MappedType.c

@@ -31,6 +31,7 @@
 
 #include <ffi.h>
 #include "rbffi.h"
+#include "compat.h"
 
 #include "Type.h"
 #include "MappedType.h"
@@ -38,24 +39,41 @@
 
 static VALUE mapped_allocate(VALUE);
 static VALUE mapped_initialize(VALUE, VALUE);
-static void mapped_mark(MappedType *);
+static void mapped_mark(void *);
+static void mapped_compact(void *);
+static size_t mapped_memsize(const void *);
 static ID id_native_type, id_to_native, id_from_native;
 
 VALUE rbffi_MappedTypeClass = Qnil;
 
+static const rb_data_type_t mapped_type_data_type = {
+  .wrap_struct_name = "FFI::Type::Mapped",
+  .function = {
+      .dmark = mapped_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = mapped_memsize,
+      ffi_compact_callback( mapped_compact )
+  },
+  .parent = &rbffi_type_data_type,
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
+
 static VALUE
 mapped_allocate(VALUE klass)
 {
     MappedType* m;
 
-    VALUE obj = Data_Make_Struct(klass, MappedType, mapped_mark, -1, m);
+    VALUE obj = TypedData_Make_Struct(klass, MappedType, &mapped_type_data_type, m);
 
-    m->rbConverter = Qnil;
-    m->rbType = Qnil;
+    RB_OBJ_WRITE(obj, &m->rbConverter, Qnil);
+    RB_OBJ_WRITE(obj, &m->rbType, Qnil);
     m->type = NULL;
     m->base.nativeType = NATIVE_MAPPED;
     m->base.ffiType = &ffi_type_void;
-    
+
     return obj;
 }
 
@@ -69,7 +87,7 @@ static VALUE
 mapped_initialize(VALUE self, VALUE rbConverter)
 {
     MappedType* m = NULL;
-    
+
     if (!rb_respond_to(rbConverter, id_native_type)) {
         rb_raise(rb_eNoMethodError, "native_type method not implemented");
     }
@@ -81,25 +99,42 @@ mapped_initialize(VALUE self, VALUE rbConverter)
     if (!rb_respond_to(rbConverter, id_from_native)) {
         rb_raise(rb_eNoMethodError, "from_native method not implemented");
     }
-    
-    Data_Get_Struct(self, MappedType, m);
-    m->rbType = rb_funcall2(rbConverter, id_native_type, 0, NULL);
+
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+    RB_OBJ_WRITE(self, &m->rbType, rb_funcall2(rbConverter, id_native_type, 0, NULL));
     if (!(rb_obj_is_kind_of(m->rbType, rbffi_TypeClass))) {
         rb_raise(rb_eTypeError, "native_type did not return instance of FFI::Type");
     }
 
-    m->rbConverter = rbConverter;
-    Data_Get_Struct(m->rbType, Type, m->type);
+    RB_OBJ_WRITE(self, &m->rbConverter, rbConverter);
+    TypedData_Get_Struct(m->rbType, Type, &rbffi_type_data_type, m->type);
     m->base.ffiType = m->type->ffiType;
-    
+
+    rb_obj_freeze(self);
+
     return self;
 }
 
 static void
-mapped_mark(MappedType* m)
+mapped_mark(void* data)
+{
+    MappedType* m = (MappedType*)data;
+    rb_gc_mark_movable(m->rbType);
+    rb_gc_mark_movable(m->rbConverter);
+}
+
+static void
+mapped_compact(void* data)
 {
-    rb_gc_mark(m->rbType);
-    rb_gc_mark(m->rbConverter);
+    MappedType* m = (MappedType*)data;
+    ffi_gc_location(m->rbType);
+    ffi_gc_location(m->rbConverter);
+}
+
+static size_t
+mapped_memsize(const void *data)
+{
+    return sizeof(MappedType);
 }
 
 /*
@@ -111,7 +146,7 @@ static VALUE
 mapped_native_type(VALUE self)
 {
     MappedType*m = NULL;
-    Data_Get_Struct(self, MappedType, m);
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
 
     return m->rbType;
 }
@@ -124,9 +159,8 @@ static VALUE
 mapped_to_native(int argc, VALUE* argv, VALUE self)
 {
     MappedType*m = NULL;
-    
-    Data_Get_Struct(self, MappedType, m);
-    
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+
     return rb_funcall2(m->rbConverter, id_to_native, argc, argv);
 }
 
@@ -138,20 +172,28 @@ static VALUE
 mapped_from_native(int argc, VALUE* argv, VALUE self)
 {
     MappedType*m = NULL;
-    
-    Data_Get_Struct(self, MappedType, m);
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
 
     return rb_funcall2(m->rbConverter, id_from_native, argc, argv);
 }
 
+static VALUE
+mapped_converter(VALUE self)
+{
+    MappedType*m = NULL;
+    TypedData_Get_Struct(self, MappedType, &mapped_type_data_type, m);
+
+    return m->rbConverter;
+}
+
 void
 rbffi_MappedType_Init(VALUE moduleFFI)
 {
-    /* 
+    /*
      * Document-class: FFI::Type::Mapped < FFI::Type
      */
     rbffi_MappedTypeClass = rb_define_class_under(rbffi_TypeClass, "Mapped", rbffi_TypeClass);
-    
+
     rb_global_variable(&rbffi_MappedTypeClass);
 
     id_native_type = rb_intern("native_type");
@@ -164,5 +206,6 @@ rbffi_MappedType_Init(VALUE moduleFFI)
     rb_define_method(rbffi_MappedTypeClass, "native_type", mapped_native_type, 0);
     rb_define_method(rbffi_MappedTypeClass, "to_native", mapped_to_native, -1);
     rb_define_method(rbffi_MappedTypeClass, "from_native", mapped_from_native, -1);
+    rb_define_method(rbffi_MappedTypeClass, "converter", mapped_converter, 0);
 }