ffi 0.3.0 → 0.4.0

data/ext/ffi_c/LastError.c

@@ -0,0 +1,135 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ruby.h>
+
+#include "LastError.h"
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+# include <pthread.h>
+#endif
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_PTHREAD_LOCAL
+#endif
+
+typedef struct ThreadData {
+    int td_errno;
+} ThreadData;
+
+#if defined(USE_PTHREAD_LOCAL)
+static pthread_key_t threadDataKey;
+#endif
+
+static inline ThreadData* thread_data_get(void);
+
+#if defined(USE_PTHREAD_LOCAL)
+
+static ThreadData*
+thread_data_init(void)
+{
+    ThreadData* td = ALLOC_N(ThreadData, 1);
+
+    memset(td, 0, sizeof(*td));
+    pthread_setspecific(threadDataKey, td);
+
+    return td;
+}
+
+
+static inline ThreadData*
+thread_data_get(void)
+{
+    ThreadData* td = pthread_getspecific(threadDataKey);
+    return td != NULL ? td : thread_data_init();
+}
+
+static void
+thread_data_free(void *ptr)
+{
+    xfree(ptr);
+}
+
+#else
+static ID id_thread_data;
+
+static ThreadData*
+thread_data_init(void)
+{
+    ThreadData* td;
+    VALUE obj;
+
+    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
+    rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);
+
+    return td;
+}
+
+static inline ThreadData*
+thread_data_get()
+{
+    VALUE obj = rb_thread_local_aref(rb_thread_current(), id_thread_data);
+
+    if (obj != Qnil && TYPE(obj) == T_DATA) {
+        return (ThreadData *) DATA_PTR(obj);
+    }
+
+    return thread_data_init();
+}
+
+#endif
+
+
+static VALUE
+get_last_error(VALUE self)
+{
+    return INT2NUM(thread_data_get()->td_errno);
+}
+
+
+static VALUE
+set_last_error(VALUE self, VALUE error)
+{
+
+#ifdef _WIN32
+    SetLastError(NUM2INT(error));
+#else
+    errno = NUM2INT(error);
+#endif
+
+    return Qnil;
+}
+
+
+void
+rbffi_save_errno(void)
+{
+    int error = 0;
+
+#ifdef _WIN32
+    error = GetLastError();
+#else
+    error = errno;
+#endif
+
+    thread_data_get()->td_errno = error;
+}
+
+
+void
+rbffi_LastError_Init(VALUE moduleFFI)
+{
+    VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
+
+    rb_define_module_function(moduleError, "error", get_last_error, 0);
+    rb_define_module_function(moduleError, "error=", set_last_error, 1);
+
+#if defined(USE_PTHREAD_LOCAL)
+    pthread_key_create(&threadDataKey, thread_data_free);
+#else
+    id_thread_data = rb_intern("ffi_thread_local_data");
+#endif /* USE_PTHREAD_LOCAL */
+}

data/ext/ffi_c/LastError.h

@@ -0,0 +1,18 @@
+#ifndef RBFFI_LASTERROR_H
+#define	RBFFI_LASTERROR_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+void rbffi_LastError_Init(VALUE moduleFFI);
+
+void rbffi_save_errno(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_LASTERROR_H */
+

data/ext/ffi_c/MemoryPointer.c

@@ -20,21 +20,26 @@ static void memptr_release(MemoryPointer* ptr);
 static VALUE memptr_malloc(VALUE self, long size, long count, bool clear);
 static VALUE memptr_free(VALUE self);
 
-VALUE rb_FFI_MemoryPointer_class;
-static VALUE classMemoryPointer = Qnil;
-#define MEMPTR(obj) ((MemoryPointer *) rb_FFI_AbstractMemory_cast(obj, rb_FFI_MemoryPointer_class))
+VALUE rbffi_MemoryPointerClass;
+
+#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, rbffi_MemoryPointerClass))
+
+static ID plus_id = 0;
 
 VALUE
-rb_FFI_MemoryPointer_new(long size, long count, bool clear)
+rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
 {
-    return memptr_malloc(memptr_allocate(classMemoryPointer), size, count, clear);
+    return memptr_malloc(memptr_allocate(rbffi_MemoryPointerClass), size, count, clear);
 }
 
 static VALUE
 memptr_allocate(VALUE klass)
 {
     MemoryPointer* p;
-    return Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
 }
 
 static VALUE
@@ -42,12 +47,14 @@ memptr_initialize(int argc, VALUE* argv, VALUE self)
 {
     VALUE size = Qnil, count = Qnil, clear = Qnil;
     int nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
-    memptr_malloc(self, rb_FFI_type_size(size), nargs > 1 ? NUM2LONG(count) : 1,
-        nargs > 2 && RTEST(clear));
+
+    memptr_malloc(self, rbffi_type_size(size), nargs > 1 ? NUM2LONG(count) : 1,
+        RTEST(clear) || clear == Qnil);
     
     if (rb_block_given_p()) {
-        return rb_rescue(rb_yield, self, memptr_free, self);
+        return rb_ensure(rb_yield, self, memptr_free, self);
     }
+
     return self;
 }
 
@@ -97,7 +104,7 @@ memptr_aref(VALUE self, VALUE which)
 {
     MemoryPointer* ptr = MEMPTR(self);
     VALUE offset = INT2NUM(ptr->type_size * NUM2INT(which));
-    return rb_funcall2(self, rb_intern("+"), 1, &offset);
+    return rb_funcall2(self, plus_id, 1, &offset);
 }
 
 static VALUE
@@ -132,15 +139,18 @@ memptr_release(MemoryPointer* ptr)
 }
 
 void
-rb_FFI_MemoryPointer_Init()
+rbffi_MemoryPointer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_MemoryPointer_class = classMemoryPointer = rb_define_class_under(moduleFFI, "MemoryPointer", rb_FFI_Pointer_class);
-    rb_define_alloc_func(classMemoryPointer, memptr_allocate);
-    rb_define_method(classMemoryPointer, "initialize", memptr_initialize, -1);
-    rb_define_method(classMemoryPointer, "inspect", memptr_inspect, 0);
-    rb_define_method(classMemoryPointer, "autorelease=", memptr_autorelease, 1);
-    rb_define_method(classMemoryPointer, "free", memptr_free, 0);
-    rb_define_method(classMemoryPointer, "type_size", memptr_type_size, 0);
-    rb_define_method(classMemoryPointer, "[]", memptr_aref, 1);
+    rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_MemoryPointerClass);
+
+    rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
+    rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
+    rb_define_method(rbffi_MemoryPointerClass, "inspect", memptr_inspect, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "autorelease=", memptr_autorelease, 1);
+    rb_define_method(rbffi_MemoryPointerClass, "free", memptr_free, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "type_size", memptr_type_size, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "[]", memptr_aref, 1);
+    
+    plus_id = rb_intern("+");
 }

data/ext/ffi_c/MemoryPointer.h

@@ -9,9 +9,9 @@
 extern "C" {
 #endif
 
-    extern void rb_FFI_MemoryPointer_Init();
-    extern VALUE rb_FFI_MemoryPointer_class;
-    extern VALUE rb_FFI_MemoryPointer_new(long size, long count, bool clear);
+    extern void rbffi_MemoryPointer_Init(VALUE moduleFFI);
+    extern VALUE rbffi_MemoryPointerClass;
+    extern VALUE rbffi_MemoryPointer_NewInstance(long size, long count, bool clear);
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/NullPointer.c

@@ -7,13 +7,13 @@
 #include "AbstractMemory.h"
 #include "Pointer.h"
 
-static VALUE NullPointerError;
-static VALUE classNullPointer;
-VALUE rb_FFI_NullPointer_class;
-VALUE rb_FFI_NullPointer_singleton;
+static VALUE NullPointerErrorClass;
 
-VALUE
-rb_FFI_NullPointer_allocate(VALUE klass)
+VALUE rbffi_NullPointerClass;
+VALUE rbffi_NullPointerSingleton;
+
+static VALUE
+nullptr_allocate(VALUE klass)
 {
     AbstractMemory* p;
     VALUE retval;
@@ -21,13 +21,29 @@ rb_FFI_NullPointer_allocate(VALUE klass)
     retval = Data_Make_Struct(klass, AbstractMemory, NULL, -1, p);
     p->address = 0;
     p->size = 0;
+    p->ops = &rbffi_NullPointerOps;
+
     return retval;
 }
 
 static VALUE
 nullptr_op(int argc, VALUE* argv, VALUE self)
 {
-    rb_raise(NullPointerError, "NULL Pointer access attempted");
+    rb_raise(NullPointerErrorClass, "NULL Pointer access attempted");
+    return Qnil;
+}
+
+static VALUE
+nullptr_op_get(AbstractMemory* ptr, long offset)
+{
+    rb_raise(NullPointerErrorClass, "NULL Pointer access attempted");
+    return Qnil;
+}
+
+static void
+nullptr_op_put(AbstractMemory* ptr, long offset, VALUE value)
+{
+    rb_raise(NullPointerErrorClass, "NULL Pointer access attempted");
 }
 
 static VALUE
@@ -46,10 +62,13 @@ static VALUE
 nullptr_equals(VALUE self, VALUE other)
 {
     AbstractMemory* p2;
-    if (!rb_obj_is_kind_of(other, rb_FFI_Pointer_class)) {
+
+    if (!rb_obj_is_kind_of(other, rbffi_PointerClass)) {
         rb_raise(rb_eArgError, "Comparing Pointer with non Pointer");
     }
+
     Data_Get_Struct(other, AbstractMemory, p2);
+
     return p2->address == 0 ? Qtrue : Qfalse;
 }
 
@@ -59,25 +78,44 @@ nullptr_address(VALUE self)
     return INT2NUM(0);
 }
 
+static MemoryOp NullPointerMemoryOp = { nullptr_op_get, nullptr_op_put };
+
+MemoryOps rbffi_NullPointerOps = {
+    .int8 = &NullPointerMemoryOp,
+    .uint8 = &NullPointerMemoryOp,
+    .int16 = &NullPointerMemoryOp,
+    .int16 = &NullPointerMemoryOp,
+    .int32 = &NullPointerMemoryOp,
+    .uint32 = &NullPointerMemoryOp,
+    .int64 = &NullPointerMemoryOp,
+    .uint64 = &NullPointerMemoryOp,
+    .float32 = &NullPointerMemoryOp,
+    .float64 = &NullPointerMemoryOp,
+    .pointer = &NullPointerMemoryOp,
+    .strptr = &NullPointerMemoryOp,
+};
 
 void
-rb_FFI_NullPointer_Init()
+rbffi_NullPointer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_NullPointer_class = classNullPointer = rb_define_class_under(moduleFFI, "NullPointer", rb_FFI_Pointer_class);
-    NullPointerError = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
-    rb_define_alloc_func(classNullPointer, rb_FFI_NullPointer_allocate);
-    rb_define_method(classNullPointer, "inspect", nullptr_inspect, 0);
-    rb_define_method(classNullPointer, "+", nullptr_op, -1);
-    rb_define_method(classNullPointer, "null?", nullptr_null_p, 0);
-    rb_define_method(classNullPointer, "address", nullptr_address, 0);
-    rb_define_method(classNullPointer, "==", nullptr_equals, 1);
+    rbffi_NullPointerClass = rb_define_class_under(moduleFFI, "NullPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_NullPointerClass);
+    
+    NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
+    rb_global_variable(&NullPointerErrorClass);
+
+    rb_define_alloc_func(rbffi_NullPointerClass, nullptr_allocate);
+    rb_define_method(rbffi_NullPointerClass, "inspect", nullptr_inspect, 0);
+    rb_define_method(rbffi_NullPointerClass, "+", nullptr_op, -1);
+    rb_define_method(rbffi_NullPointerClass, "null?", nullptr_null_p, 0);
+    rb_define_method(rbffi_NullPointerClass, "address", nullptr_address, 0);
+    rb_define_method(rbffi_NullPointerClass, "==", nullptr_equals, 1);
 
 #define NOP(name) \
-    rb_define_method(classNullPointer, "get_" #name, nullptr_op, -1); \
-    rb_define_method(classNullPointer, "put_" #name, nullptr_op, -1); \
-    rb_define_method(classNullPointer, "get_array_of_" #name, nullptr_op, -1); \
-    rb_define_method(classNullPointer, "put_array_of_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "get_array_of_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "put_array_of_" #name, nullptr_op, -1); \
 
 
     NOP(int8); NOP(uint8); NOP(int16); NOP(uint16);
@@ -89,16 +127,17 @@ rb_FFI_NullPointer_Init()
 
 #undef NOP
 #define NOP(name) \
-    rb_define_method(classNullPointer, "get_" #name, nullptr_op,  -1); \
-    rb_define_method(classNullPointer, "put_" #name, nullptr_op, -1);
+    rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op,  -1); \
+    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1);
 
     NOP(string); NOP(bytes); NOP(pointer); NOP(callback);
 
-    rb_define_method(classNullPointer, "clear", nullptr_op, -1); \
-    rb_define_method(classNullPointer, "total", nullptr_op, -1);
+    rb_define_method(rbffi_NullPointerClass, "clear", nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "total", nullptr_op, -1);
 
     // Create a singleton instance of NullPointer that can be shared
-    rb_FFI_NullPointer_singleton = rb_FFI_NullPointer_allocate(classNullPointer);
-    rb_gc_register_address(&rb_FFI_NullPointer_singleton);
+    rbffi_NullPointerSingleton = nullptr_allocate(rbffi_NullPointerClass);
+    rb_global_variable(&rbffi_NullPointerSingleton);
+    rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
 }
 

data/ext/ffi_c/Platform.c

@@ -4,9 +4,10 @@
 #include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
+#include "endian.h"
 #include "Platform.h"
 
-static VALUE modulePlatform = Qnil;
+static VALUE PlatformModule = Qnil;
 
 /*
  * Determine the cpu type at compile time - useful for MacOSX where the the
@@ -47,14 +48,12 @@ export_primitive_types(VALUE module)
 }
 
 void
-rb_FFI_Platform_Init()
+rbffi_Platform_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    VALUE platform = rb_define_module_under(moduleFFI, "Platform");
-    rb_define_const(platform, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
-    rb_define_const(platform, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
-    rb_define_const(platform, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
-    rb_define_const(platform, "CPU", rb_str_new2(CPU));
-    export_primitive_types(platform);
-    modulePlatform = platform;
+    PlatformModule = rb_define_module_under(moduleFFI, "Platform");
+    rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
+    rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
+    rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
+    rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
+    export_primitive_types(PlatformModule);
 }

data/ext/ffi_c/Platform.h

@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-    extern void rb_FFI_Platform_Init();
+    extern void rbffi_Platform_Init(VALUE moduleFFI);
 
 
 #ifdef	__cplusplus

data/ext/ffi_c/Pointer.c

@@ -11,35 +11,73 @@ typedef struct Pointer {
     VALUE parent;
 } Pointer;
 
-#define POINTER(obj) rb_FFI_AbstractMemory_cast((obj), rb_FFI_Pointer_class)
+#define POINTER(obj) rbffi_AbstractMemory_Cast((obj), rbffi_PointerClass)
 
-VALUE rb_FFI_Pointer_class;
-static VALUE classPointer = Qnil;
+VALUE rbffi_PointerClass;
 static void ptr_mark(Pointer* ptr);
-static void ptr_free(Pointer* ptr);
 
 VALUE
-rb_FFI_Pointer_new(void* addr)
+rbffi_Pointer_NewInstance(void* addr)
 {
     Pointer* p;
-    VALUE retval;
+    VALUE obj;
+
     if (addr == NULL) {
-        return rb_FFI_NullPointer_singleton;
+        return rbffi_NullPointerSingleton;
     }
-    retval = Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+
+    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = Qnil;
-    return retval;
+
+    return obj;
 }
 
 static VALUE
 ptr_allocate(VALUE klass)
 {
     Pointer* p;
-    return Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+    VALUE obj;
+
+    obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
+    p->parent = Qnil;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
 }
 
+static VALUE
+ptr_initialize(int argc, VALUE* argv, VALUE self)
+{
+    Pointer* p;
+    VALUE type, address;
+
+    Data_Get_Struct(self, Pointer, p);
+
+    switch (rb_scan_args(argc, argv, "11", &type, &address)) {
+        case 1:
+            p->memory.address = (void*)(uintptr_t) NUM2LL(type);
+            // FIXME set type_size to 1
+            break;
+        case 2:
+            p->memory.address = (void*)(uintptr_t) NUM2LL(address);
+            // FIXME set type_size to rbffi_type_size(type)
+            break;
+        default:
+            rb_raise(rb_eArgError, "Invalid arguments");
+    }
+    if (p->memory.address == NULL) {
+        p->memory.ops = &rbffi_NullPointerOps;
+    }
+
+    p->memory.size = LONG_MAX;
+    
+    return self;
+}
+
+
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
@@ -51,10 +89,11 @@ ptr_plus(VALUE self, VALUE offset)
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, off, 1);
 
-    retval = Data_Make_Struct(classPointer, Pointer, ptr_mark, ptr_free, p);
+    retval = Data_Make_Struct(rbffi_PointerClass, Pointer, ptr_mark, -1, p);
 
     p->memory.address = ptr->address + off;
     p->memory.size = ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = self;
 
     return retval;
@@ -76,7 +115,9 @@ static VALUE
 ptr_null_p(VALUE self)
 {
     Pointer* ptr;
+
     Data_Get_Struct(self, Pointer, ptr);
+
     return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
@@ -84,6 +125,7 @@ static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
+    
     Data_Get_Struct(self, Pointer, ptr);
 
     return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
@@ -93,6 +135,7 @@ static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
+    
     Data_Get_Struct(self, Pointer, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
@@ -101,27 +144,21 @@ ptr_address(VALUE self)
 static void
 ptr_mark(Pointer* ptr)
 {
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
-}
-
-static void
-ptr_free(Pointer* ptr)
-{
-    xfree(ptr);
+    rb_gc_mark(ptr->parent);
 }
 
 void
-rb_FFI_Pointer_Init()
+rbffi_Pointer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_Pointer_class = classPointer = rb_define_class_under(moduleFFI, "Pointer", rb_FFI_AbstractMemory_class);
-
-    rb_define_alloc_func(classPointer, ptr_allocate);
-    rb_define_method(classPointer, "inspect", ptr_inspect, 0);
-    rb_define_method(classPointer, "+", ptr_plus, 1);
-    rb_define_method(classPointer, "null?", ptr_null_p, 0);
-    rb_define_method(classPointer, "address", ptr_address, 0);
-    rb_define_method(classPointer, "==", ptr_equals, 1);
+    rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
+    rb_global_variable(&rbffi_PointerClass);
+
+    rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
+    rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
+    rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
+    rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
+    rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
+    rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
+    rb_define_alias(rbffi_PointerClass, "to_i", "address");
+    rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
 }

data/ext/ffi_c/Pointer.h

@@ -6,14 +6,16 @@
 extern "C" {
 #endif
 
+#include "AbstractMemory.h"
 
+extern void rbffi_Pointer_Init(VALUE moduleFFI);
+extern void rbffi_NullPointer_Init(VALUE moduleFFI);
+extern VALUE rbffi_Pointer_NewInstance(void* addr);
+extern VALUE rbffi_PointerClass;
+extern VALUE rbffi_NullPointerClass;
+extern VALUE rbffi_NullPointerSingleton;
+extern MemoryOps rbffi_NullPointerOps;
 
-extern void rb_FFI_Pointer_Init(void);
-extern void rb_FFI_NullPointer_Init();
-extern VALUE rb_FFI_Pointer_new(void* addr);
-extern VALUE rb_FFI_Pointer_class;
-extern VALUE rb_FFI_NullPointer_class;
-extern VALUE rb_FFI_NullPointer_singleton;
 
 #ifdef	__cplusplus
 }