ffi 0.1.1 → 0.2.0

data/ext/MemoryPointer.c

@@ -4,113 +4,65 @@
 #include <ruby.h>
 #include "rbffi.h"
 #include "AbstractMemory.h"
+#include "Pointer.h"
 #include "MemoryPointer.h"
 
 typedef struct MemoryPointer {
     AbstractMemory memory;
-    VALUE parent;
+    caddr_t address;
     bool autorelease;
     bool allocated;
 } MemoryPointer;
 
 static VALUE memptr_allocate(VALUE self, VALUE size, VALUE count, VALUE clear);
 static void memptr_release(MemoryPointer* ptr);
-static void memptr_mark(MemoryPointer* ptr);
 
 VALUE rb_FFI_MemoryPointer_class;
 static VALUE classMemoryPointer = Qnil;
 
-VALUE
-rb_FFI_MemoryPointer_new(caddr_t addr)
-{
-    MemoryPointer* p;
-    
-    p = ALLOC(MemoryPointer);
-    memset(p, 0, sizeof(*p));
-    p->memory.address = addr;
-    p->memory.size = LONG_MAX;
-    p->parent = Qnil;
-    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
-}
-
 static VALUE
 memptr_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
 {
     MemoryPointer* p;
-    
-    p = ALLOC(MemoryPointer);
-    memset(p, 0, sizeof(*p));
+    VALUE retval;
+    caddr_t memory;
+    unsigned long msize = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
+    memory = malloc(msize + 7);
+    if (memory == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", msize);
+    }
+    retval = Data_Make_Struct(classMemoryPointer, MemoryPointer, NULL, memptr_release, p);
+    p->address = memory;
     p->autorelease = true;
-    p->memory.size = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
-    p->memory.address = p->memory.size > 0 ? malloc(p->memory.size) : NULL;
-    p->parent = Qnil;
+    p->memory.size = msize;
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (caddr_t) (((uintptr_t) memory + 0x7) & (uintptr_t) ~0x7UL);;
     p->allocated = true;
-
-    if (p->memory.address == NULL) {
-        long size = p->memory.size;
-        xfree(p);
-        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", size);
-    }
-    if (TYPE(clear) == T_TRUE) {
+    if (TYPE(clear) == T_TRUE && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
-    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
+    return retval;
 }
 
-static VALUE
-memptr_plus(VALUE self, VALUE offset)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
-    MemoryPointer* p;
-    long off = NUM2LONG(offset);
-
-    checkBounds(&ptr->memory, off, 1);
-    p = ALLOC(MemoryPointer);
-    memset(p, 0, sizeof(*p));
-    p->memory.address = ptr->memory.address + off;;
-    p->memory.size = ptr->memory.size - off;;
-    p->parent = self;
-    p->allocated = false;
-    p->autorelease = true;
-    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
-}
 
 static VALUE
 memptr_inspect(VALUE self)
 {
     MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
     char tmp[100];
-    snprintf(tmp, sizeof(tmp), "#<MemoryPointer address=%p>", ptr->memory.address);
+    snprintf(tmp, sizeof(tmp), "#<MemoryPointer address=%p size=%lu>", ptr->memory.address, ptr->memory.size);
     return rb_str_new2(tmp);
 }
 
-static VALUE
-memptr_null_p(VALUE self)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
-    return ptr->memory.address == NULL ? Qtrue : Qfalse;
-}
-
-static VALUE
-memptr_equals(VALUE self, VALUE other)
-{
-    MemoryPointer* p1 = (MemoryPointer *) DATA_PTR(self);
-    MemoryPointer* p2;
-    
-    if (!rb_obj_is_kind_of(other, classMemoryPointer)) {
-        rb_raise(rb_eArgError, "Comparing MemoryPointer with non MemoryPointer");
-    }
-    p2 = (MemoryPointer *) DATA_PTR(other);
-    return p1->memory.address == p2->memory.address ? Qtrue : Qfalse;
-}
-
 static VALUE
 memptr_free(VALUE self)
 {
     MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
     if (ptr->allocated) {
-        free(ptr->memory.address);
-        ptr->memory.address = NULL;
+        if (ptr->address != NULL) {
+            free(ptr->address);
+            ptr->address = NULL;
+        }
         ptr->allocated = false;
     }
     return self;
@@ -124,41 +76,24 @@ memptr_autorelease(VALUE self, VALUE autorelease)
     return self;
 }
 
-static VALUE
-memptr_address(VALUE self)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);    
-    return ULL2NUM((uintptr_t) ptr->memory.address);
-}
-
 static void
 memptr_release(MemoryPointer* ptr)
 {
-    if (ptr->autorelease && ptr->allocated) {
-        free(ptr->memory.address);
+    if (ptr->autorelease && ptr->allocated && ptr->address != NULL) {
+        free(ptr->address);
+        ptr->address = NULL;
     }
     xfree(ptr);
 
 }
-static void
-memptr_mark(MemoryPointer* ptr)
-{
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
-}
 
 void
 rb_FFI_MemoryPointer_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
-    rb_FFI_MemoryPointer_class = classMemoryPointer = rb_define_class_under(moduleFFI, "MemoryPointer", rb_FFI_AbstractMemory_class);
+    rb_FFI_MemoryPointer_class = classMemoryPointer = rb_define_class_under(moduleFFI, "MemoryPointer", rb_FFI_Pointer_class);
     rb_define_singleton_method(classMemoryPointer, "__allocate", memptr_allocate, 3);
     rb_define_method(classMemoryPointer, "inspect", memptr_inspect, 0);
-    rb_define_method(classMemoryPointer, "+", memptr_plus, 1);
-    rb_define_method(classMemoryPointer, "null?", memptr_null_p, 0);
     rb_define_method(classMemoryPointer, "autorelease=", memptr_autorelease, 1);
     rb_define_method(classMemoryPointer, "free", memptr_free, 0);
-    rb_define_method(classMemoryPointer, "address", memptr_address, 0);
-    rb_define_method(classMemoryPointer, "==", memptr_equals, 1);
 }

data/ext/NativeLibrary.c

@@ -0,0 +1,90 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <dlfcn.h>
+#include <ruby.h>
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "compat.h"
+#include "Pointer.h"
+#include "NativeLibrary.h"
+
+static void library_free(Library* lib);
+static VALUE classLibrary;
+
+static VALUE
+library_open(VALUE klass, VALUE libname, VALUE libflags)
+{
+    VALUE retval;
+    Library* library;
+    int flags;
+    Check_Type(libflags, T_FIXNUM);
+
+    flags = libflags != Qnil ? NUM2UINT(libflags) : 0;
+    if (flags == 0) {
+        flags = RTLD_LAZY;
+    }
+    retval = Data_Make_Struct(klass, Library, NULL, library_free, library);
+    library->handle = dlopen(libname != Qnil ? StringValueCStr(libname) : NULL,
+        RTLD_LAZY);
+    if (library->handle == NULL) {
+        rb_raise(rb_eLoadError, "Could not open library '%s': %s",
+                libname != Qnil ? StringValueCStr(libname) : "[current process]",
+                dlerror());
+    }
+    rb_iv_set(retval, "@name", libname != Qnil ? libname : rb_str_new2("[current process]"));
+    return retval;
+}
+
+static VALUE
+library_dlsym(VALUE self, VALUE name)
+{
+    Library* library;
+    void* address = NULL;
+    Check_Type(name, T_STRING);
+
+    Data_Get_Struct(self, Library, library);
+    address = dlsym(library->handle, StringValueCStr(name));
+    return address != NULL ? rb_FFI_Pointer_new(address) : Qnil;
+}
+
+static VALUE
+library_dlerror(VALUE self)
+{
+    return rb_tainted_str_new2(dlerror());
+}
+
+static void
+library_free(Library* library)
+{
+    if (library != NULL) {
+        // dlclose() on MacOS tends to segfault - avoid it
+#ifndef __APPLE__
+        if (library->handle != NULL) {
+            dlclose(library->handle);
+        }
+#endif
+        library->handle = NULL;
+        xfree(library);
+    }
+}
+
+void
+rb_FFI_NativeLibrary_Init()
+{
+    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_singleton_method(classLibrary, "open", library_open, 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))
+    DEF(LAZY);
+    DEF(NOW);
+    DEF(GLOBAL);
+    DEF(LOCAL);
+}
+

data/ext/NativeLibrary.h

@@ -0,0 +1,22 @@
+
+#ifndef _LIBRARY_H
+#define	_LIBRARY_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+
+typedef struct Library {
+    void* handle;
+} Library;
+
+extern void rb_FFI_NativeLibrary_Init();
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _LIBRARY_H */
+

data/ext/Platform.c

@@ -1,5 +1,6 @@
 #include <sys/param.h>
 #include <sys/types.h>
+#include <stdint.h>
 #include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
@@ -26,16 +27,34 @@ static VALUE modulePlatform = Qnil;
 #error "Unknown cpu type"
 #endif
 
+static void
+export_primitive_types(VALUE module)
+{
+#define S(name, T) do { \
+    typedef struct { char c; T v; } s; \
+    rb_define_const(module, #name "_ALIGN", INT2NUM((sizeof(s) - sizeof(T)) * 8)); \
+    rb_define_const(module, #name "_SIZE", INT2NUM(sizeof(T)* 8)); \
+} while(0)
+    S(INT8, char);
+    S(INT16, short);
+    S(INT32, int);
+    S(INT64, long long);
+    S(LONG, long);
+    S(FLOAT, float);
+    S(DOUBLE, double);
+    S(ADDRESS, void*);
+#undef S
+}
+
 void
 rb_FFI_Platform_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
     VALUE platform = rb_define_module_under(moduleFFI, "Platform");
-    rb_define_const(platform, "LONG_SIZE", INT2FIX(sizeof(long) * 8));
-    rb_define_const(platform, "ADDRESS_SIZE", INT2FIX(sizeof(void *) * 8));
     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;
 }

data/ext/Pointer.c

@@ -0,0 +1,107 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+
+typedef struct Pointer {
+    AbstractMemory memory;
+    VALUE parent;
+} Pointer;
+
+VALUE rb_FFI_Pointer_class;
+static VALUE classPointer = Qnil;
+static void ptr_mark(Pointer* ptr);
+static void ptr_free(Pointer* ptr);
+
+VALUE
+rb_FFI_Pointer_new(caddr_t addr)
+{
+    Pointer* p;
+    VALUE retval;
+    retval = Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+    p->memory.address = addr;
+    p->memory.size = LONG_MAX;
+    p->parent = Qnil;
+    return retval;
+}
+
+static VALUE
+ptr_plus(VALUE self, VALUE offset)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    Pointer* p;
+    VALUE retval;
+    long off = NUM2LONG(offset);
+
+    checkBounds(ptr, off, 1);
+    retval = Data_Make_Struct(classPointer, Pointer, ptr_mark, ptr_free, p);
+    p->memory.address = ptr->address + off;
+    p->memory.size = ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off;
+    p->parent = self;
+    return retval;
+}
+
+static VALUE
+ptr_inspect(VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    char tmp[100];
+    snprintf(tmp, sizeof(tmp), "#<Native Pointer address=%p>", ptr->address);
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+ptr_null_p(VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    return ptr->address == NULL ? Qtrue : Qfalse;
+}
+
+static VALUE
+ptr_equals(VALUE self, VALUE other)
+{
+    AbstractMemory* p1 = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* p2;
+
+    if (!rb_obj_is_kind_of(other, classPointer)) {
+        rb_raise(rb_eArgError, "Comparing Pointer with non Pointer");
+    }
+    p2 = (AbstractMemory *) DATA_PTR(other);
+    return p1->address == p2->address ? Qtrue : Qfalse;
+}
+
+static VALUE
+ptr_address(VALUE self)
+{
+    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    return ULL2NUM((uintptr_t) ptr->address);
+}
+
+static void
+ptr_mark(Pointer* ptr)
+{
+    if (ptr->parent != Qnil) {
+        rb_gc_mark(ptr->parent);
+    }
+}
+
+static void
+ptr_free(Pointer* ptr)
+{
+    xfree(ptr);
+}
+
+void
+rb_FFI_Pointer_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    rb_FFI_Pointer_class = classPointer = rb_define_class_under(moduleFFI, "Pointer", rb_FFI_AbstractMemory_class);
+    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);
+}

data/ext/Pointer.h

@@ -0,0 +1,21 @@
+
+#ifndef _POINTER_H
+#define	_POINTER_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+
+extern void rb_FFI_Pointer_Init(void);
+extern VALUE rb_FFI_Pointer_new(caddr_t addr);
+extern VALUE rb_FFI_Pointer_class;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _POINTER_H */
+