ffi 0.4.0-x86-mswin32

data/ext/ffi_c/AbstractMemory.h

@@ -0,0 +1,68 @@
+#ifndef _ABSTRACTMEMORY_H
+#define	_ABSTRACTMEMORY_H
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdint.h>
+
+#include "compat.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+typedef struct AbstractMemory_ AbstractMemory;
+
+typedef struct {
+    VALUE (*get)(AbstractMemory* ptr, long offset);
+    void (*put)(AbstractMemory* ptr, long offset, VALUE value);
+} MemoryOp;
+
+typedef struct {
+    MemoryOp* int8;
+    MemoryOp* uint8;
+    MemoryOp* int16;
+    MemoryOp* uint16;
+    MemoryOp* int32;
+    MemoryOp* uint32;
+    MemoryOp* int64;
+    MemoryOp* uint64;
+    MemoryOp* float32;
+    MemoryOp* float64;
+    MemoryOp* pointer;
+    MemoryOp* strptr;
+} MemoryOps;
+
+struct AbstractMemory_ {
+    char* address; // Use char* instead of void* to ensure adding to it works correctly
+    long size;
+    MemoryOps* ops;
+};
+
+
+static inline void
+checkBounds(AbstractMemory* mem, long off, long len)
+{
+    if ((off | len | (off + len) | (mem->size - (off + len))) < 0) {
+        rb_raise(rb_eIndexError, "Memory access offset=%ld size=%ld is out of bounds",
+                off, len);
+    }
+}
+
+#define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), rbffi_AbstractMemoryClass)
+#define MEMORY_PTR(obj) MEMORY((obj))->address
+#define MEMORY_LEN(obj) MEMORY((obj))->size
+
+extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
+
+extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
+
+extern VALUE rbffi_AbstractMemoryClass;
+extern MemoryOps rbffi_AbstractMemoryOps;
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _ABSTRACTMEMORY_H */
+

data/ext/ffi_c/AutoPointer.c

@@ -0,0 +1,60 @@
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "AutoPointer.h"
+
+typedef struct AutoPointer {
+    AbstractMemory memory;
+    VALUE parent;
+} AutoPointer;
+
+static void autoptr_mark(AutoPointer* ptr);
+static VALUE autoptr_allocate(VALUE klass);
+static VALUE autoptr_set_parent(VALUE self, VALUE parent);
+
+VALUE rbffi_AutoPointerClass = Qnil;
+
+static VALUE
+autoptr_allocate(VALUE klass)
+{
+    AutoPointer* p;
+    VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
+    p->parent = Qnil;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
+}
+
+static VALUE
+autoptr_set_parent(VALUE self, VALUE parent)
+{
+    AutoPointer* p;
+    AbstractMemory* ptr = rbffi_AbstractMemory_Cast(parent, rbffi_PointerClass);
+
+    Data_Get_Struct(self, AutoPointer, p);
+    p->memory = *ptr;
+    p->parent = parent;
+
+    return self;
+}
+
+static void
+autoptr_mark(AutoPointer* ptr)
+{
+    rb_gc_mark(ptr->parent);
+}
+
+void
+rbffi_AutoPointer_Init(VALUE moduleFFI)
+{
+    rbffi_AutoPointerClass = rb_define_class_under(moduleFFI, "AutoPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_AutoPointerClass);
+    
+    rb_define_alloc_func(rbffi_AutoPointerClass, autoptr_allocate);
+    rb_define_protected_method(rbffi_AutoPointerClass, "parent=", autoptr_set_parent, 1);
+}

data/ext/ffi_c/AutoPointer.h

@@ -0,0 +1,18 @@
+
+#ifndef _AUTOPOINTER_H
+#define	_AUTOPOINTER_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern void rbffi_AutoPointer_Init(VALUE ffiModule);
+extern VALUE rbffi_AutoPointerClass;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _AUTOPOINTER_H */
+

data/ext/ffi_c/Buffer.c

@@ -0,0 +1,171 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+
+typedef struct Buffer {
+    AbstractMemory memory;
+    char* storage; /* start of malloc area */
+    int type_size;
+    VALUE parent;
+} Buffer;
+
+static VALUE buffer_allocate(VALUE klass);
+static VALUE buffer_initialize(int argc, VALUE* argv, VALUE self);
+static void buffer_release(Buffer* ptr);
+static void buffer_mark(Buffer* ptr);
+static VALUE buffer_free(VALUE self);
+
+static VALUE BufferClass = Qnil;
+#define BUFFER(obj)  ((Buffer *) rbffi_AbstractMemory_Cast((obj), BufferClass))
+
+static VALUE
+buffer_allocate(VALUE klass)
+{
+    Buffer* buffer;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
+    buffer->parent = Qnil;
+    buffer->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    
+    xfree(ptr);
+}
+
+static VALUE
+buffer_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE size = Qnil, count = Qnil, clear = Qnil;
+    Buffer* p;
+    int nargs;
+
+    Data_Get_Struct(self, Buffer, p);
+
+    nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
+    p->type_size = rbffi_type_size(size);
+    p->memory.size = p->type_size * (nargs > 1 ? NUM2LONG(count) : 1);
+
+    p->storage = malloc(p->memory.size + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
+    }
+
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
+    
+    if (nargs > 2 && (RTEST(clear) || clear == Qnil) && p->memory.size > 0) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, self, buffer_free, self);
+    }
+
+    return self;
+}
+
+static VALUE
+buffer_alloc_inout(int argc, VALUE* argv, VALUE klass)
+{
+    return buffer_initialize(argc, argv, buffer_allocate(klass));
+}
+
+static VALUE
+buffer_plus(VALUE self, VALUE offset)
+{
+    Buffer* ptr = BUFFER(self);
+    Buffer* p;
+    VALUE retval;
+    long off = NUM2LONG(offset);
+
+    checkBounds(&ptr->memory, off, 1);
+
+    retval = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, p);
+    p->memory.address = ptr->memory.address + off;
+    p->memory.size = ptr->memory.size - off;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->parent = self;
+
+    return retval;
+}
+
+static VALUE
+buffer_aref(VALUE self, VALUE offset)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    return buffer_plus(self, INT2FIX(ptr->type_size * NUM2INT(offset)));
+}
+
+static VALUE
+buffer_type_size(VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    return INT2NUM(ptr->type_size);
+}
+
+static VALUE
+buffer_inspect(VALUE self)
+{
+    char tmp[100];
+
+    snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", BUFFER(self)->memory.size);
+    
+    return rb_str_new2(tmp);
+}
+
+/* Only used to free the buffer if the yield in the initializer throws an exception */
+static VALUE
+buffer_free(VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    if (ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+
+    return self;
+}
+
+static void
+buffer_mark(Buffer* ptr)
+{
+    rb_gc_mark(ptr->parent);
+}
+
+void
+rbffi_Buffer_Init(VALUE moduleFFI)
+{
+    BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
+
+    rb_global_variable(&BufferClass);
+    rb_define_alloc_func(BufferClass, buffer_allocate);
+
+    rb_define_singleton_method(BufferClass, "alloc_inout", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_out", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_in", buffer_alloc_inout, -1);
+    
+    rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
+    rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
+    rb_define_method(BufferClass, "type_size", buffer_type_size, 0);
+    rb_define_method(BufferClass, "[]", buffer_aref, 1);
+    rb_define_method(BufferClass, "+", buffer_plus, 1);
+}

data/ext/ffi_c/Callback.c

@@ -0,0 +1,374 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#ifndef _WIN32
+# include <sys/mman.h>
+#endif
+#include <ruby.h>
+#include <ffi.h>
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "MemoryPointer.h"
+#include "Callback.h"
+#include "Types.h"
+#include "Type.h"
+#include "rbffi.h"
+#include "compat.h"
+#include "extconf.h"
+
+static void cbinfo_mark(CallbackInfo* cbInfo);
+static void cbinfo_free(CallbackInfo *);
+
+#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
+static void* ffi_closure_alloc(size_t size, void** code);
+static void ffi_closure_free(void* ptr);
+ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
+        void (*fun)(ffi_cif*, void*, void**, void*),
+        void* user_data, void* code);
+#endif /* HAVE_FFI_CLOSURE_ALLOC */
+
+static VALUE CallbackInfoClass = Qnil;
+static VALUE NativeCallbackClass = Qnil;
+static ID id_call = Qnil, id_cbtable = Qnil;
+
+VALUE rbffi_CallbackInfoClass = Qnil;
+
+static VALUE
+cbinfo_allocate(VALUE klass)
+{
+    CallbackInfo* cbInfo;
+    VALUE obj = Data_Make_Struct(klass, CallbackInfo, cbinfo_mark, cbinfo_free, cbInfo);
+
+    cbInfo->type.ffiType = &ffi_type_pointer;
+    cbInfo->type.size = ffi_type_pointer.size;
+    cbInfo->type.alignment = ffi_type_pointer.alignment;
+    cbInfo->type.nativeType = NATIVE_CALLBACK;
+    cbInfo->rbReturnType = Qnil;
+
+    return obj;
+}
+
+static VALUE
+cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
+{
+    CallbackInfo *cbInfo;
+    int paramCount;
+    ffi_status status;
+    int i;
+
+    Check_Type(rbParamTypes, T_ARRAY);
+
+    
+    paramCount = RARRAY_LEN(rbParamTypes);
+
+    Data_Get_Struct(self, CallbackInfo, cbInfo);
+    cbInfo->parameterCount = paramCount;
+    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(*cbInfo->parameterTypes));
+    cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
+    Data_Get_Struct(rbReturnType, Type, cbInfo->returnType);
+    cbInfo->rbReturnType = rbReturnType;
+    cbInfo->rbParameterTypes = rbParamTypes;
+
+    for (i = 0; i < paramCount; ++i) {
+        VALUE entry = rb_ary_entry(rbParamTypes, i);
+        if (!rb_obj_is_kind_of(entry, rbffi_TypeClass)) {
+            rb_raise(rb_eTypeError, "Invalid parameter type");
+        }
+        Data_Get_Struct(entry, Type, cbInfo->parameterTypes[i]);
+        cbInfo->ffiParameterTypes[i] = cbInfo->parameterTypes[i]->ffiType;
+        if (cbInfo->ffiParameterTypes[i] == NULL) {
+            rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]->nativeType);
+        }
+    }
+
+    if (!rb_obj_is_kind_of(rbReturnType, rbffi_TypeClass)) {
+        rb_raise(rb_eTypeError, "Invalid return type");
+    }
+
+    cbInfo->ffiReturnType = cbInfo->returnType->ffiType;
+    if (cbInfo->ffiReturnType == NULL) {
+        rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType->nativeType);
+    }
+#if defined(_WIN32) && defined(notyet)
+    cbInfo->abi = (flags & STDCALL) ? FFI_STDCALL : FFI_DEFAULT_ABI;
+#else
+    cbInfo->abi = FFI_DEFAULT_ABI;
+#endif
+    status = ffi_prep_cif(&cbInfo->ffi_cif, cbInfo->abi, cbInfo->parameterCount, 
+            cbInfo->ffiReturnType, cbInfo->ffiParameterTypes);
+    switch (status) {
+        case FFI_BAD_ABI:
+            rb_raise(rb_eArgError, "Invalid ABI specified");
+        case FFI_BAD_TYPEDEF:
+            rb_raise(rb_eArgError, "Invalid argument type specified");
+        case FFI_OK:
+            break;
+        default:
+            rb_raise(rb_eArgError, "Unknown FFI error");
+    }
+    return self;
+}
+
+static void
+cbinfo_mark(CallbackInfo* cbInfo)
+{
+    rb_gc_mark(cbInfo->rbReturnType);
+    rb_gc_mark(cbInfo->rbParameterTypes);
+}
+
+static void
+cbinfo_free(CallbackInfo* cbInfo)
+{
+    if (cbInfo->parameterTypes != NULL) {
+        xfree(cbInfo->parameterTypes);
+    }
+    if (cbInfo->ffiParameterTypes != NULL) {
+        xfree(cbInfo->ffiParameterTypes);
+    }
+    xfree(cbInfo);
+}
+
+static void
+native_callback_free(NativeCallback* cb)
+{
+    if (cb->ffi_closure != NULL) {
+        ffi_closure_free(cb->ffi_closure);
+    }
+    xfree(cb);
+}
+
+static void
+native_callback_mark(NativeCallback* cb)
+{
+    rb_gc_mark(cb->rbCallbackInfo);
+    rb_gc_mark(cb->rbProc);
+}
+
+static void
+native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
+{
+    NativeCallback* cb = (NativeCallback *) user_data;
+    CallbackInfo *cbInfo = cb->cbInfo;
+    VALUE* rbParams;
+    VALUE rbReturnValue;
+    int i;
+
+    rbParams = ALLOCA_N(VALUE, cbInfo->parameterCount);
+    for (i = 0; i < cbInfo->parameterCount; ++i) {
+        VALUE param;
+        switch (cbInfo->parameterTypes[i]->nativeType) {
+            case NATIVE_INT8:
+                param = INT2NUM(*(int8_t *) parameters[i]);
+                break;
+            case NATIVE_UINT8:
+                param = UINT2NUM(*(uint8_t *) parameters[i]);
+                break;
+            case NATIVE_INT16:
+                param = INT2NUM(*(int16_t *) parameters[i]);
+                break;
+            case NATIVE_UINT16:
+                param = UINT2NUM(*(uint16_t *) parameters[i]);
+                break;
+            case NATIVE_INT32:
+                param = INT2NUM(*(int32_t *) parameters[i]);
+                break;
+            case NATIVE_UINT32:
+                param = UINT2NUM(*(uint32_t *) parameters[i]);
+                break;
+            case NATIVE_INT64:
+                param = LL2NUM(*(int64_t *) parameters[i]);
+                break;
+            case NATIVE_UINT64:
+                param = ULL2NUM(*(uint64_t *) parameters[i]);
+                break;
+            case NATIVE_FLOAT32:
+                param = rb_float_new(*(float *) parameters[i]);
+                break;
+            case NATIVE_FLOAT64:
+                param = rb_float_new(*(double *) parameters[i]);
+                break;
+            case NATIVE_STRING:
+                param = rb_tainted_str_new2(*(char **) parameters[i]);
+                break;
+            case NATIVE_POINTER:
+                param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
+                break;
+            case NATIVE_BOOL:
+                param = (*(void **) parameters[i]) ? Qtrue : Qfalse;
+                break;
+            case NATIVE_CALLBACK:
+                param = rbffi_NativeValue_ToRuby(cbInfo->parameterTypes[i],
+                     rb_ary_entry(cbInfo->rbParameterTypes, i), parameters[i], Qnil);
+                break;
+            default:
+                param = Qnil;
+                break;
+        }
+        rbParams[i] = param;
+    }
+    rbReturnValue = rb_funcall2(cb->rbProc, id_call, cbInfo->parameterCount, rbParams);
+    if (rbReturnValue == Qnil || TYPE(rbReturnValue) == T_NIL) {
+        memset(retval, 0, cbInfo->ffiReturnType->size);
+    } else switch (cbInfo->returnType->nativeType) {
+        case NATIVE_INT8:
+        case NATIVE_INT16:
+        case NATIVE_INT32:
+            *((ffi_sarg *) retval) = NUM2INT(rbReturnValue);
+            break;
+        case NATIVE_UINT8:
+        case NATIVE_UINT16:
+        case NATIVE_UINT32:
+            *((ffi_arg *) retval) = NUM2UINT(rbReturnValue);
+            break;
+        case NATIVE_INT64:
+            *((int64_t *) retval) = NUM2LL(rbReturnValue);
+            break;
+        case NATIVE_UINT64:
+            *((uint64_t *) retval) = NUM2ULL(rbReturnValue);
+            break;
+        case NATIVE_FLOAT32:
+            *((float *) retval) = (float) NUM2DBL(rbReturnValue);
+            break;
+        case NATIVE_FLOAT64:
+            *((double *) retval) = NUM2DBL(rbReturnValue);
+            break;
+        case NATIVE_POINTER:
+            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
+                *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
+            } else {
+                // Default to returning NULL if not a value pointer object.  handles nil case as well
+                *((void **) retval) = NULL;
+            }
+            break;
+        case NATIVE_BOOL:
+            *((ffi_sarg *) retval) = TYPE(rbReturnValue) == T_TRUE ? 1 : 0;
+            break;
+        case NATIVE_CALLBACK:
+            if (rb_obj_is_kind_of(rbReturnValue, rb_cProc) || rb_respond_to(rbReturnValue, id_call)) {
+                VALUE callback;
+
+                callback = rbffi_NativeCallback_ForProc(rbReturnValue, cbInfo->rbReturnType);
+                
+                *((void **) retval) = ((NativeCallback *) DATA_PTR(callback))->code;
+            } else {
+                *((void **) retval) = NULL;
+            }
+            break;
+
+        default:
+            *((ffi_arg *) retval) = 0;
+            break;
+    }
+}
+
+static VALUE
+native_callback_allocate(VALUE klass)
+{
+    NativeCallback* closure;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->rbCallbackInfo = Qnil;
+    closure->rbProc = Qnil;
+    
+    return obj;
+}
+
+VALUE
+rbffi_NativeCallback_NewInstance(VALUE rbCallbackInfo, VALUE rbProc)
+{
+    NativeCallback* closure = NULL;
+    CallbackInfo* cbInfo;
+    VALUE obj;
+    ffi_status status;
+
+    Data_Get_Struct(rbCallbackInfo, CallbackInfo, cbInfo);
+    obj = Data_Make_Struct(NativeCallbackClass, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->cbInfo = cbInfo;
+    closure->rbProc = rbProc;
+    closure->rbCallbackInfo = rbCallbackInfo;
+
+    closure->ffi_closure = ffi_closure_alloc(sizeof(*closure->ffi_closure), &closure->code);
+    if (closure->ffi_closure == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate FFI native closure");
+    }
+
+    status = ffi_prep_closure_loc(closure->ffi_closure, &cbInfo->ffi_cif,
+            native_callback_invoke, closure, closure->code);
+    if (status != FFI_OK) {
+        rb_raise(rb_eArgError, "ffi_prep_closure_loc failed");
+    }
+
+    return obj;
+}
+
+VALUE
+rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo)
+{
+    VALUE callback;
+    VALUE cbTable = RTEST(rb_ivar_defined(proc, id_cbtable)) ? rb_ivar_get(proc, id_cbtable) : Qnil;
+    if (cbTable == Qnil) {
+        cbTable = rb_hash_new();
+        rb_ivar_set(proc, id_cbtable, cbTable);
+    }
+    callback = rb_hash_aref(cbTable, cbInfo);
+    if (callback != Qnil) {
+        return callback;
+    }
+    callback = rbffi_NativeCallback_NewInstance(cbInfo, proc);
+    rb_hash_aset(cbTable, cbInfo, callback);
+    return callback;
+}
+#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
+/*
+ * versions of ffi_closure_alloc, ffi_closure_free and ffi_prep_closure_loc for older
+ * system libffi versions.
+ */
+static void*
+ffi_closure_alloc(size_t size, void** code)
+{
+    void* closure;
+    closure = mmap(NULL, size, PROT_READ | PROT_WRITE,
+             MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (closure == (void *) -1) {
+        return NULL;
+    }
+    memset(closure, 0, size);
+    *code = closure;
+    return closure;
+}
+
+static void
+ffi_closure_free(void* ptr)
+{
+    munmap(ptr, sizeof(ffi_closure));
+}
+
+ffi_status
+ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
+        void (*fun)(ffi_cif*, void*, void**, void*),
+        void* user_data, void* code)
+{
+    ffi_status retval = ffi_prep_closure(closure, cif, fun, user_data);
+    if (retval == FFI_OK) {
+        mprotect(closure, sizeof(ffi_closure), PROT_READ | PROT_EXEC);
+    }
+    return retval;
+}
+
+#endif /* HAVE_FFI_CLOSURE_ALLOC */
+
+void
+rbffi_Callback_Init(VALUE moduleFFI)
+{
+    rbffi_CallbackInfoClass = CallbackInfoClass = rb_define_class_under(moduleFFI, "CallbackInfo", rbffi_TypeClass);
+    rb_global_variable(&rbffi_CallbackInfoClass);
+
+    rb_define_alloc_func(CallbackInfoClass, cbinfo_allocate);
+    rb_define_method(CallbackInfoClass, "initialize", cbinfo_initialize, 2);
+
+    NativeCallbackClass = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
+    rb_global_variable(&NativeCallbackClass);
+    rb_define_alloc_func(NativeCallbackClass, native_callback_allocate);
+    id_call = rb_intern("call");
+    id_cbtable = rb_intern("@__ffi_callback_table__");
+}