ffi 0.3.5 → 0.4.0

data/ext/ffi_c/AutoPointer.c

@@ -17,7 +17,7 @@ static void autoptr_mark(AutoPointer* ptr);
 static VALUE autoptr_allocate(VALUE klass);
 static VALUE autoptr_set_parent(VALUE self, VALUE parent);
 
-VALUE rb_FFI_AutoPointer_class = Qnil;
+VALUE rbffi_AutoPointerClass = Qnil;
 
 static VALUE
 autoptr_allocate(VALUE klass)
@@ -25,7 +25,7 @@ autoptr_allocate(VALUE klass)
     AutoPointer* p;
     VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
     p->parent = Qnil;
-    p->memory.ops = &rb_FFI_AbstractMemory_ops;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
 
     return obj;
 }
@@ -34,7 +34,7 @@ static VALUE
 autoptr_set_parent(VALUE self, VALUE parent)
 {
     AutoPointer* p;
-    AbstractMemory* ptr = rb_FFI_AbstractMemory_cast(parent, rb_FFI_Pointer_class);
+    AbstractMemory* ptr = rbffi_AbstractMemory_Cast(parent, rbffi_PointerClass);
 
     Data_Get_Struct(self, AutoPointer, p);
     p->memory = *ptr;
@@ -50,12 +50,11 @@ autoptr_mark(AutoPointer* ptr)
 }
 
 void
-rb_FFI_AutoPointer_Init()
+rbffi_AutoPointer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_AutoPointer_class = rb_define_class_under(moduleFFI, "AutoPointer", rb_FFI_Pointer_class);
-    rb_global_variable(&rb_FFI_AutoPointer_class);
+    rbffi_AutoPointerClass = rb_define_class_under(moduleFFI, "AutoPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_AutoPointerClass);
     
-    rb_define_alloc_func(rb_FFI_AutoPointer_class, autoptr_allocate);
-    rb_define_protected_method(rb_FFI_AutoPointer_class, "parent=", autoptr_set_parent, 1);
+    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

@@ -6,8 +6,8 @@
 extern "C" {
 #endif
 
-extern void rb_FFI_AutoPointer_Init(void);
-extern VALUE rb_FFI_AutoPointer_class;
+extern void rbffi_AutoPointer_Init(VALUE ffiModule);
+extern VALUE rbffi_AutoPointerClass;
 
 
 #ifdef	__cplusplus

data/ext/ffi_c/Buffer.c

@@ -18,8 +18,8 @@ static void buffer_release(Buffer* ptr);
 static void buffer_mark(Buffer* ptr);
 static VALUE buffer_free(VALUE self);
 
-static VALUE classBuffer = Qnil;
-#define BUFFER(obj)  ((Buffer *) rb_FFI_AbstractMemory_cast((obj), classBuffer))
+static VALUE BufferClass = Qnil;
+#define BUFFER(obj)  ((Buffer *) rbffi_AbstractMemory_Cast((obj), BufferClass))
 
 static VALUE
 buffer_allocate(VALUE klass)
@@ -29,7 +29,7 @@ buffer_allocate(VALUE klass)
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
     buffer->parent = Qnil;
-    buffer->memory.ops = &rb_FFI_AbstractMemory_ops;
+    buffer->memory.ops = &rbffi_AbstractMemoryOps;
 
     return obj;
 }
@@ -55,7 +55,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     Data_Get_Struct(self, Buffer, p);
 
     nargs = rb_scan_args(argc, argv, "12", &size, &count, &clear);
-    p->type_size = rb_FFI_type_size(size);
+    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);
@@ -66,7 +66,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     /* 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) && p->memory.size > 0) {
+    if (nargs > 2 && (RTEST(clear) || clear == Qnil) && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
 
@@ -93,10 +93,10 @@ buffer_plus(VALUE self, VALUE offset)
 
     checkBounds(&ptr->memory, off, 1);
 
-    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, -1, p);
+    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 = &rb_FFI_AbstractMemory_ops;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->parent = self;
 
     return retval;
@@ -152,21 +152,20 @@ buffer_mark(Buffer* ptr)
 }
 
 void
-rb_FFI_Buffer_Init()
+rbffi_Buffer_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
+    BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
 
-    rb_global_variable(&classBuffer);
-    rb_define_alloc_func(classBuffer, buffer_allocate);
+    rb_global_variable(&BufferClass);
+    rb_define_alloc_func(BufferClass, buffer_allocate);
 
-    rb_define_singleton_method(classBuffer, "alloc_inout", buffer_alloc_inout, -1);
-    rb_define_singleton_method(classBuffer, "alloc_out", buffer_alloc_inout, -1);
-    rb_define_singleton_method(classBuffer, "alloc_in", buffer_alloc_inout, -1);
+    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(classBuffer, "initialize", buffer_initialize, -1);
-    rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
-    rb_define_method(classBuffer, "type_size", buffer_type_size, 0);
-    rb_define_method(classBuffer, "[]", buffer_aref, 1);
-    rb_define_method(classBuffer, "+", buffer_plus, 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

@@ -10,11 +10,12 @@
 #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)
@@ -25,17 +26,25 @@ ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
         void* user_data, void* code);
 #endif /* HAVE_FFI_CLOSURE_ALLOC */
 
-static VALUE classCallbackInfo = Qnil;
-static VALUE classNativeCallback = Qnil;
-static ID callID = Qnil, cbTableID = Qnil;
+static VALUE CallbackInfoClass = Qnil;
+static VALUE NativeCallbackClass = Qnil;
+static ID id_call = Qnil, id_cbtable = Qnil;
 
-VALUE rb_FFI_CallbackInfo_class = Qnil;
+VALUE rbffi_CallbackInfoClass = Qnil;
 
 static VALUE
 cbinfo_allocate(VALUE klass)
 {
     CallbackInfo* cbInfo;
-    return Data_Make_Struct(klass, CallbackInfo, NULL, cbinfo_free, 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
@@ -47,25 +56,37 @@ cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
     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(NativeType));
+    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(*cbInfo->parameterTypes));
     cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
-    cbInfo->returnType = FIX2INT(rbReturnType);
+    Data_Get_Struct(rbReturnType, Type, cbInfo->returnType);
+    cbInfo->rbReturnType = rbReturnType;
+    cbInfo->rbParameterTypes = rbParamTypes;
 
     for (i = 0; i < paramCount; ++i) {
-        cbInfo->parameterTypes[i] = FIX2INT(rb_ary_entry(rbParamTypes, i));
-        cbInfo->ffiParameterTypes[i] = rb_FFI_NativeTypeToFFI(cbInfo->parameterTypes[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]);
+            rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]->nativeType);
         }
     }
 
-    cbInfo->ffiReturnType = rb_FFI_NativeTypeToFFI(cbInfo->returnType);
+    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);
+        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;
@@ -87,6 +108,13 @@ cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
     return self;
 }
 
+static void
+cbinfo_mark(CallbackInfo* cbInfo)
+{
+    rb_gc_mark(cbInfo->rbReturnType);
+    rb_gc_mark(cbInfo->rbParameterTypes);
+}
+
 static void
 cbinfo_free(CallbackInfo* cbInfo)
 {
@@ -127,7 +155,7 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     rbParams = ALLOCA_N(VALUE, cbInfo->parameterCount);
     for (i = 0; i < cbInfo->parameterCount; ++i) {
         VALUE param;
-        switch (cbInfo->parameterTypes[i]) {
+        switch (cbInfo->parameterTypes[i]->nativeType) {
             case NATIVE_INT8:
                 param = INT2NUM(*(int8_t *) parameters[i]);
                 break;
@@ -162,7 +190,14 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
                 param = rb_tainted_str_new2(*(char **) parameters[i]);
                 break;
             case NATIVE_POINTER:
-                param = rb_FFI_Pointer_new(*(void **) parameters[i]);
+                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;
@@ -170,10 +205,10 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
         }
         rbParams[i] = param;
     }
-    rbReturnValue = rb_funcall2(cb->rbProc, callID, cbInfo->parameterCount, rbParams);
+    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) {
+    } else switch (cbInfo->returnType->nativeType) {
         case NATIVE_INT8:
         case NATIVE_INT16:
         case NATIVE_INT32:
@@ -197,14 +232,30 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
             *((double *) retval) = NUM2DBL(rbReturnValue);
             break;
         case NATIVE_POINTER:
-            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rb_FFI_Pointer_class)) {
+            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;
     }
 }
@@ -223,7 +274,7 @@ native_callback_allocate(VALUE klass)
 }
 
 VALUE
-rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
+rbffi_NativeCallback_NewInstance(VALUE rbCallbackInfo, VALUE rbProc)
 {
     NativeCallback* closure = NULL;
     CallbackInfo* cbInfo;
@@ -231,7 +282,7 @@ rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
     ffi_status status;
 
     Data_Get_Struct(rbCallbackInfo, CallbackInfo, cbInfo);
-    obj = Data_Make_Struct(classNativeCallback, NativeCallback, native_callback_mark, native_callback_free, closure);
+    obj = Data_Make_Struct(NativeCallbackClass, NativeCallback, native_callback_mark, native_callback_free, closure);
     closure->cbInfo = cbInfo;
     closure->rbProc = rbProc;
     closure->rbCallbackInfo = rbCallbackInfo;
@@ -251,19 +302,19 @@ rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
 }
 
 VALUE
-rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo)
+rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo)
 {
     VALUE callback;
-    VALUE cbTable = RTEST(rb_ivar_defined(proc, cbTableID)) ? rb_ivar_get(proc, cbTableID) : Qnil;
+    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, cbTableID, cbTable);
+        rb_ivar_set(proc, id_cbtable, cbTable);
     }
     callback = rb_hash_aref(cbTable, cbInfo);
     if (callback != Qnil) {
         return callback;
     }
-    callback = rb_FFI_NativeCallback_new(cbInfo, proc);
+    callback = rbffi_NativeCallback_NewInstance(cbInfo, proc);
     rb_hash_aset(cbTable, cbInfo, callback);
     return callback;
 }
@@ -307,16 +358,17 @@ ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
 #endif /* HAVE_FFI_CLOSURE_ALLOC */
 
 void
-rb_FFI_Callback_Init()
+rbffi_Callback_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
+    rbffi_CallbackInfoClass = CallbackInfoClass = rb_define_class_under(moduleFFI, "CallbackInfo", rbffi_TypeClass);
+    rb_global_variable(&rbffi_CallbackInfoClass);
 
-    rb_FFI_CallbackInfo_class = classCallbackInfo = rb_define_class_under(moduleFFI, "CallbackInfo", rb_cObject);
-    rb_define_alloc_func(classCallbackInfo, cbinfo_allocate);
-    rb_define_method(classCallbackInfo, "initialize", cbinfo_initialize, 2);
+    rb_define_alloc_func(CallbackInfoClass, cbinfo_allocate);
+    rb_define_method(CallbackInfoClass, "initialize", cbinfo_initialize, 2);
 
-    classNativeCallback = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
-    rb_define_alloc_func(classNativeCallback, native_callback_allocate);
-    callID = rb_intern("call");
-    cbTableID = rb_intern("@__ffi_callback_table__");
+    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__");
 }

data/ext/ffi_c/Callback.h

@@ -2,6 +2,7 @@
 #define	_CALLBACK_H
 
 #include "Types.h"
+#include "Type.h"
 
 #ifdef	__cplusplus
 extern "C" {
@@ -9,8 +10,12 @@ extern "C" {
 #include <ffi.h>
     
 typedef struct {
-    NativeType returnType;
-    NativeType* parameterTypes;
+    Type type; // The native type of a CallbackInfo object
+    VALUE rbReturnType;
+    VALUE rbParameterTypes;
+
+    Type* returnType;
+    Type** parameterTypes;
     ffi_type* ffiReturnType;
     ffi_type** ffiParameterTypes;
     ffi_cif ffi_cif;
@@ -29,9 +34,10 @@ typedef struct {
     VALUE rbProc;
 } NativeCallback;
 
-extern VALUE rb_FFI_CallbackInfo_class;
-extern VALUE rb_FFI_NativeCallback_new(VALUE, VALUE);
-extern VALUE rb_FFI_NativeCallback_for_proc(VALUE proc, VALUE cbInfo);
+extern VALUE rbffi_CallbackInfoClass;
+extern void rbffi_Callback_Init(VALUE ffiModule);
+extern VALUE rbffi_NativeCallback_NewInstance(VALUE, VALUE);
+extern VALUE rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo);
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/{NativeLibrary.c → DynamicLibrary.c}

@@ -12,12 +12,25 @@
 
 #include "rbffi.h"
 #include "compat.h"
+#include "AbstractMemory.h"
 #include "Pointer.h"
-#include "NativeLibrary.h"
+#include "DynamicLibrary.h"
+
+typedef struct LibrarySymbol_ {
+    AbstractMemory memory;
+    VALUE library;
+    VALUE name;
+} LibrarySymbol;
 
 static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
 static void library_free(Library* lib);
-static VALUE classLibrary;
+
+
+static VALUE symbol_allocate(VALUE klass);
+static VALUE symbol_new(VALUE library, void* address, VALUE name);
+static void symbol_mark(LibrarySymbol* sym);
+
+static VALUE LibraryClass = Qnil, SymbolClass = Qnil;
 
 #if defined(_WIN32) || defined(__WIN32__)
 static void* dl_open(const char* name, int flags);
@@ -80,7 +93,8 @@ library_dlsym(VALUE self, VALUE name)
 
     Data_Get_Struct(self, Library, library);
     address = dl_sym(library->handle, StringValueCStr(name));
-    return address != NULL ? rb_FFI_Pointer_new(address) : Qnil;
+    
+    return address != NULL ? symbol_new(self, address, name) : Qnil;
 }
 
 static VALUE
@@ -122,21 +136,74 @@ dl_error(char* buf, int size)
 }
 #endif
 
+static VALUE
+symbol_allocate(VALUE klass)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(klass, LibrarySymbol, NULL, -1, sym);
+    sym->name = Qnil;
+    sym->library = Qnil;
+
+    return obj;
+}
+
+static VALUE
+symbol_new(VALUE library, void* address, VALUE name)
+{
+    LibrarySymbol* sym;
+    VALUE obj = Data_Make_Struct(SymbolClass, LibrarySymbol, symbol_mark, -1, sym);
+
+    sym->memory.address = address;
+    sym->memory.size = LONG_MAX;
+    sym->library = library;
+    sym->name = name;
+
+    return obj;
+}
+
+static void
+symbol_mark(LibrarySymbol* sym)
+{
+    rb_gc_mark(sym->library);
+    rb_gc_mark(sym->name);
+}
+
+static VALUE
+symbol_inspect(VALUE self)
+{
+    LibrarySymbol* sym;
+    char buf[256];
+
+    Data_Get_Struct(self, LibrarySymbol, sym);
+    snprintf(buf, sizeof(buf), "#<FFI::Library::Symbol name=%s address=%p>",
+             StringValueCStr(sym->name), sym->memory.address);
+    return rb_str_new2(buf);
+}
+
 void
-rb_FFI_NativeLibrary_Init()
+rbffi_DynamicLibrary_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    classLibrary = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
-    rb_define_const(moduleFFI, "NativeLibrary", classLibrary); // backwards compat library
-    rb_define_alloc_func(classLibrary, library_allocate);
-    rb_define_singleton_method(classLibrary, "open", library_open, 2);
-    rb_define_singleton_method(classLibrary, "last_error", library_dlerror, 0);
-    rb_define_method(classLibrary, "initialize", library_initialize, 2);
-    rb_define_method(classLibrary, "find_symbol", library_dlsym, 1);
-    rb_define_method(classLibrary, "last_error", library_dlerror, 0);
-    rb_define_attr(classLibrary, "name", 1, 0);
-
-#define DEF(x) rb_define_const(classLibrary, "RTLD_" #x, UINT2NUM(RTLD_##x))
+    LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
+    rb_global_variable(&LibraryClass);
+    SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass);
+    rb_global_variable(&SymbolClass);
+
+    rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library
+    rb_define_alloc_func(LibraryClass, library_allocate);
+    rb_define_singleton_method(LibraryClass, "open", library_open, 2);
+    rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_method(LibraryClass, "initialize", library_initialize, 2);
+    rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1);
+    rb_define_method(LibraryClass, "find_function", library_dlsym, 1);
+    rb_define_method(LibraryClass, "find_variable", library_dlsym, 1);
+    rb_define_method(LibraryClass, "last_error", library_dlerror, 0);
+    rb_define_attr(LibraryClass, "name", 1, 0);
+
+    rb_define_alloc_func(SymbolClass, symbol_allocate);
+    rb_undef_method(SymbolClass, "new");
+    rb_define_method(SymbolClass, "inspect", symbol_inspect, 0);
+
+#define DEF(x) rb_define_const(LibraryClass, "RTLD_" #x, UINT2NUM(RTLD_##x))
     DEF(LAZY);
     DEF(NOW);
     DEF(GLOBAL);