ffi 0.2.0 → 0.3.0

data/ext/ffi_c/MemoryPointer.c

@@ -0,0 +1,146 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "MemoryPointer.h"
+
+typedef struct MemoryPointer {
+    AbstractMemory memory;
+    char* storage; /* start of malloc area */
+    int type_size;
+    bool autorelease;
+    bool allocated;
+} MemoryPointer;
+
+static VALUE memptr_allocate(VALUE klass);
+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
+rb_FFI_MemoryPointer_new(long size, long count, bool clear)
+{
+    return memptr_malloc(memptr_allocate(classMemoryPointer), size, count, clear);
+}
+
+static VALUE
+memptr_allocate(VALUE klass)
+{
+    MemoryPointer* p;
+    return Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+}
+
+static VALUE
+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));
+    
+    if (rb_block_given_p()) {
+        return rb_rescue(rb_yield, self, memptr_free, self);
+    }
+    return self;
+}
+
+static VALUE
+memptr_malloc(VALUE self, long size, long count, bool clear)
+{
+    MemoryPointer* p;
+    unsigned long msize;
+
+    Data_Get_Struct(self, MemoryPointer, p);
+    p->type_size = size;
+
+    msize = size * count;
+
+    p->storage = malloc(msize + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", msize);
+    }
+    p->autorelease = true;
+    p->memory.size = msize;
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);;
+    p->allocated = true;
+    if (clear && p->memory.size > 0) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+    return self;
+}
+
+static VALUE
+memptr_inspect(VALUE self)
+{
+    MemoryPointer* ptr = MEMPTR(self);
+    char tmp[100];
+    snprintf(tmp, sizeof(tmp), "#<MemoryPointer address=%p size=%lu>", ptr->memory.address, ptr->memory.size);
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+memptr_type_size(VALUE self)
+{
+    return INT2FIX(MEMPTR(self)->type_size);
+}
+
+static VALUE
+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);
+}
+
+static VALUE
+memptr_free(VALUE self)
+{
+    MemoryPointer* ptr = MEMPTR(self);
+    if (ptr->allocated) {
+        if (ptr->storage != NULL) {
+            free(ptr->storage);
+            ptr->storage = NULL;
+        }
+        ptr->allocated = false;
+    }
+    return self;
+}
+
+static VALUE
+memptr_autorelease(VALUE self, VALUE autorelease)
+{
+    MEMPTR(self)->autorelease = autorelease == Qtrue;
+    return self;
+}
+
+static void
+memptr_release(MemoryPointer* ptr)
+{
+    if (ptr->autorelease && ptr->allocated && ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+    xfree(ptr);
+}
+
+void
+rb_FFI_MemoryPointer_Init()
+{
+    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);
+}

data/ext/{MemoryPointer.h → ffi_c/MemoryPointer.h}

@@ -1,13 +1,8 @@
-/* 
- * File:   MemoryPointer.h
- * Author: wayne
- *
- * Created on August 28, 2008, 5:24 PM
- */
 
 #ifndef _MEMORYPOINTER_H
 #define	_MEMORYPOINTER_H
 
+#include <stdbool.h>
 #include <ruby.h>
 
 #ifdef	__cplusplus
@@ -15,8 +10,8 @@ extern "C" {
 #endif
 
     extern void rb_FFI_MemoryPointer_Init();
-    extern VALUE rb_FFI_MemoryPointer_new(caddr_t addr);
     extern VALUE rb_FFI_MemoryPointer_class;
+    extern VALUE rb_FFI_MemoryPointer_new(long size, long count, bool clear);
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/NativeLibrary.c

@@ -0,0 +1,149 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#if defined(_WIN32) || defined(__WIN32__)
+# include <windows.h>
+#else
+# include <dlfcn.h>
+#endif
+#include <ruby.h>
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "compat.h"
+#include "Pointer.h"
+#include "NativeLibrary.h"
+
+static VALUE library_initialize(VALUE self, VALUE libname, VALUE libflags);
+static void library_free(Library* lib);
+static VALUE classLibrary;
+
+#if defined(_WIN32) || defined(__WIN32__)
+static void* dl_open(const char* name, int flags);
+static void dl_error(char* buf, int size);
+#define dl_sym(handle, name) GetProcAddress(handle, name)
+#define dl_close(handle) FreeLibrary(handle)
+enum { RTLD_LAZY=1, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL };
+#else
+# define dl_open(name, flags) dlopen(name, flags != 0 ? flags : RTLD_LAZY)
+# define dl_error(buf, size) do { snprintf(buf, size, "%s", dlerror()); } while(0)
+# define dl_sym(handle, name) dlsym(handle, name)
+# define dl_close(handle) dlclose(handle)
+#ifndef RTLD_LOCAL
+# define RTLD_LOCAL 8
+#endif
+#endif
+
+static VALUE
+library_allocate(VALUE klass)
+{
+    Library* library;
+    return Data_Make_Struct(klass, Library, NULL, library_free, library);
+}
+
+static VALUE
+library_open(VALUE klass, VALUE libname, VALUE libflags)
+{
+    return library_initialize(library_allocate(klass), libname, libflags);
+}
+
+static VALUE
+library_initialize(VALUE self, VALUE libname, VALUE libflags)
+{
+    Library* library;
+    int flags;
+
+    Check_Type(libflags, T_FIXNUM);
+
+    Data_Get_Struct(self, Library, library);
+    flags = libflags != Qnil ? NUM2UINT(libflags) : 0;
+    
+    library->handle = dl_open(libname != Qnil ? StringValueCStr(libname) : NULL, flags);
+    if (library->handle == NULL) {
+        char errmsg[1024];
+        dl_error(errmsg, sizeof(errmsg));
+        rb_raise(rb_eLoadError, "Could not open library '%s': %s",
+                libname != Qnil ? StringValueCStr(libname) : "[current process]",
+                errmsg);
+    }
+    rb_iv_set(self, "@name", libname != Qnil ? libname : rb_str_new2("[current process]"));
+    return self;
+}
+
+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 = dl_sym(library->handle, StringValueCStr(name));
+    return address != NULL ? rb_FFI_Pointer_new(address) : Qnil;
+}
+
+static VALUE
+library_dlerror(VALUE self)
+{
+    char errmsg[1024];
+    dl_error(errmsg, sizeof(errmsg));
+    return rb_tainted_str_new2(errmsg);
+}
+
+static void
+library_free(Library* library)
+{
+    if (library != NULL) {
+        // dlclose() on MacOS tends to segfault - avoid it
+#ifndef __APPLE__
+        if (library->handle != NULL) {
+            dl_close(library->handle);
+        }
+#endif
+        library->handle = NULL;
+        xfree(library);
+    }
+}
+
+#if defined(_WIN32) || defined(__WIN32__)
+static void*
+dl_open(const char* name, int flags)
+{
+    if (name == NULL) {
+        return GetModuleHandle(NULL);
+    } else {
+        return LoadLibraryEx(name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+    }
+}
+
+static void
+dl_error(char* buf, int size)
+{
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
+            0, buf, size, NULL);
+}
+#endif
+
+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_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))
+    DEF(LAZY);
+    DEF(NOW);
+    DEF(GLOBAL);
+    DEF(LOCAL);
+
+}
+

data/ext/ffi_c/NullPointer.c

@@ -0,0 +1,104 @@
+#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+
+static VALUE NullPointerError;
+static VALUE classNullPointer;
+VALUE rb_FFI_NullPointer_class;
+VALUE rb_FFI_NullPointer_singleton;
+
+VALUE
+rb_FFI_NullPointer_allocate(VALUE klass)
+{
+    AbstractMemory* p;
+    VALUE retval;
+
+    retval = Data_Make_Struct(klass, AbstractMemory, NULL, -1, p);
+    p->address = 0;
+    p->size = 0;
+    return retval;
+}
+
+static VALUE
+nullptr_op(int argc, VALUE* argv, VALUE self)
+{
+    rb_raise(NullPointerError, "NULL Pointer access attempted");
+}
+
+static VALUE
+nullptr_inspect(VALUE self)
+{
+    return rb_str_new2("#<NULL Pointer address=0x0>");
+}
+
+static VALUE
+nullptr_null_p(VALUE self)
+{
+    return Qtrue;
+}
+
+static VALUE
+nullptr_equals(VALUE self, VALUE other)
+{
+    AbstractMemory* p2;
+    if (!rb_obj_is_kind_of(other, rb_FFI_Pointer_class)) {
+        rb_raise(rb_eArgError, "Comparing Pointer with non Pointer");
+    }
+    Data_Get_Struct(other, AbstractMemory, p2);
+    return p2->address == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE
+nullptr_address(VALUE self)
+{
+    return INT2NUM(0);
+}
+
+
+void
+rb_FFI_NullPointer_Init()
+{
+    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);
+
+#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); \
+
+
+    NOP(int8); NOP(uint8); NOP(int16); NOP(uint16);
+    NOP(int32); NOP(uint32); NOP(int64); NOP(uint64); NOP(long); NOP(ulong);
+    NOP(float32); NOP(float64);
+    NOP(char); NOP(uchar); NOP(short); NOP(ushort);
+    NOP(int); NOP(uint); NOP(long_long); NOP(ulong_long);
+    NOP(float); NOP(double);
+
+#undef NOP
+#define NOP(name) \
+    rb_define_method(classNullPointer, "get_" #name, nullptr_op,  -1); \
+    rb_define_method(classNullPointer, "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);
+
+    // 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);
+}
+

data/ext/{Platform.h → ffi_c/Platform.h}

@@ -1,10 +1,3 @@
-/* 
- * File:   Platform.h
- * Author: wayne
- *
- * Created on August 29, 2008, 2:09 PM
- */
-
 #ifndef _PLATFORM_H
 #define	_PLATFORM_H
 

data/ext/{Pointer.c → ffi_c/Pointer.c}

@@ -11,16 +11,21 @@ typedef struct Pointer {
     VALUE parent;
 } Pointer;
 
+#define POINTER(obj) rb_FFI_AbstractMemory_cast((obj), rb_FFI_Pointer_class)
+
 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)
+rb_FFI_Pointer_new(void* addr)
 {
     Pointer* p;
     VALUE retval;
+    if (addr == NULL) {
+        return rb_FFI_NullPointer_singleton;
+    }
     retval = Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
@@ -28,56 +33,69 @@ rb_FFI_Pointer_new(caddr_t addr)
     return retval;
 }
 
+static VALUE
+ptr_allocate(VALUE klass)
+{
+    Pointer* p;
+    return Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+}
+
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
+    AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
     long off = NUM2LONG(offset);
 
+    Data_Get_Struct(self, AbstractMemory, ptr);
     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);
+    Pointer* ptr;
     char tmp[100];
-    snprintf(tmp, sizeof(tmp), "#<Native Pointer address=%p>", ptr->address);
+
+    Data_Get_Struct(self, Pointer, ptr);
+    snprintf(tmp, sizeof(tmp), "#<Native Pointer address=%p>", ptr->memory.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;
+    Pointer* ptr;
+    Data_Get_Struct(self, Pointer, ptr);
+    return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
 static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
-    AbstractMemory* p1 = (AbstractMemory *) DATA_PTR(self);
-    AbstractMemory* p2;
+    Pointer* ptr;
+    Data_Get_Struct(self, Pointer, ptr);
 
-    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;
+    return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
 }
 
 static VALUE
 ptr_address(VALUE self)
 {
-    AbstractMemory* ptr = (AbstractMemory *) DATA_PTR(self);
-    return ULL2NUM((uintptr_t) ptr->address);
+    Pointer* ptr;
+    Data_Get_Struct(self, Pointer, ptr);
+
+    return ULL2NUM((uintptr_t) ptr->memory.address);
 }
 
 static void
@@ -99,6 +117,8 @@ 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_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);