ffi 0.2.0 → 0.3.0

data/ext/Buffer.c

@@ -1,98 +0,0 @@
-#include <stdbool.h>
-#include <stdint.h>
-#include <limits.h>
-#include <ruby.h>
-#include "rbffi.h"
-#include "AbstractMemory.h"
-
-typedef struct Buffer {
-    AbstractMemory memory;
-    caddr_t address; /* The C heap address */
-    VALUE parent;
-} Buffer;
-
-static VALUE buffer_allocate(VALUE self, VALUE size, VALUE count, VALUE clear);
-static void buffer_release(Buffer* ptr);
-static void buffer_mark(Buffer* ptr);
-
-static VALUE classBuffer = Qnil;
-
-static VALUE
-buffer_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
-{
-    Buffer* p;
-    VALUE retval;
-    unsigned long msize = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
-    caddr_t memory;
-
-    memory = malloc(msize + 7);
-    if (memory == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", msize);
-    }
-    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
-    p->address = memory;
-    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->parent = Qnil;
-    if (TYPE(clear) == T_TRUE && p->memory.size > 0) {
-        memset(p->memory.address, 0, p->memory.size);
-    }
-    return retval;
-}
-
-static VALUE
-buffer_plus(VALUE self, VALUE offset)
-{
-    Buffer* ptr = (Buffer *) DATA_PTR(self);
-    Buffer* p;
-    VALUE retval;
-    long off = NUM2LONG(offset);
-
-    checkBounds(&ptr->memory, off, 1);
-    retval = Data_Make_Struct(classBuffer, Buffer, buffer_mark, buffer_release, p);
-    p->memory.address = ptr->memory.address + off;;
-    p->memory.size = ptr->memory.size - off;
-    p->parent = self;
-    return retval;
-}
-
-static VALUE
-buffer_inspect(VALUE self)
-{
-    Buffer* ptr = (Buffer *) DATA_PTR(self);
-    char tmp[100];
-    snprintf(tmp, sizeof(tmp), "#<Buffer size=%ld>", ptr->memory.size);
-    return rb_str_new2(tmp);
-}
-
-static void
-buffer_release(Buffer* ptr)
-{
-    if (ptr->parent == Qnil && ptr->address != NULL) {
-        free(ptr->address);
-        ptr->address = NULL;
-    }
-    xfree(ptr);
-
-}
-static void
-buffer_mark(Buffer* ptr)
-{
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
-}
-
-void
-rb_FFI_Buffer_Init()
-{
-    VALUE moduleFFI = rb_define_module("FFI");
-    classBuffer = rb_define_class_under(moduleFFI, "Buffer", rb_FFI_AbstractMemory_class);
-    rb_define_singleton_method(classBuffer, "__alloc_inout", buffer_allocate, 3);
-    rb_define_singleton_method(classBuffer, "__alloc_out", buffer_allocate, 3);
-    rb_define_singleton_method(classBuffer, "__alloc_in", buffer_allocate, 3);
-    rb_define_method(classBuffer, "inspect", buffer_inspect, 0);
-    rb_define_method(classBuffer, "+", buffer_plus, 1);
-}
-

data/ext/MemoryPointer.c

@@ -1,99 +0,0 @@
-#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;
-    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);
-
-VALUE rb_FFI_MemoryPointer_class;
-static VALUE classMemoryPointer = Qnil;
-
-static VALUE
-memptr_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
-{
-    MemoryPointer* 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 = 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 (TYPE(clear) == T_TRUE && p->memory.size > 0) {
-        memset(p->memory.address, 0, p->memory.size);
-    }
-    return retval;
-}
-
-
-static VALUE
-memptr_inspect(VALUE self)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(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_free(VALUE self)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
-    if (ptr->allocated) {
-        if (ptr->address != NULL) {
-            free(ptr->address);
-            ptr->address = NULL;
-        }
-        ptr->allocated = false;
-    }
-    return self;
-}
-
-static VALUE
-memptr_autorelease(VALUE self, VALUE autorelease)
-{
-    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
-    ptr->autorelease = autorelease == Qtrue;
-    return self;
-}
-
-static void
-memptr_release(MemoryPointer* ptr)
-{
-    if (ptr->autorelease && ptr->allocated && ptr->address != NULL) {
-        free(ptr->address);
-        ptr->address = 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_singleton_method(classMemoryPointer, "__allocate", memptr_allocate, 3);
-    rb_define_method(classMemoryPointer, "inspect", memptr_inspect, 0);
-    rb_define_method(classMemoryPointer, "autorelease=", memptr_autorelease, 1);
-    rb_define_method(classMemoryPointer, "free", memptr_free, 0);
-}

data/ext/NativeLibrary.c

@@ -1,90 +0,0 @@
-#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/Types.c

@@ -1,76 +0,0 @@
-#include <ruby.h>
-#include "Pointer.h"
-#include "Types.h"
-
-ffi_type*
-rb_FFI_NativeTypeToFFI(NativeType type)
-{
-    switch (type) {
-        case VOID:
-            return &ffi_type_void;
-        case INT8:
-            return &ffi_type_sint8;
-        case UINT8:
-            return &ffi_type_uint8;
-        case INT16:
-            return &ffi_type_sint16;
-        case UINT16:
-            return &ffi_type_uint16;
-        case INT32:
-            return &ffi_type_sint32;
-        case UINT32:
-            return &ffi_type_uint32;
-        case INT64:
-            return &ffi_type_sint64;
-        case UINT64:
-            return &ffi_type_uint64;
-        case FLOAT32:
-            return &ffi_type_float;
-        case FLOAT64:
-            return &ffi_type_double;
-        case STRING:
-        case RBXSTRING:
-        case POINTER:
-        case BUFFER_IN:
-        case BUFFER_OUT:
-        case BUFFER_INOUT:
-            return &ffi_type_pointer;
-        default:
-            return NULL;
-    }
-}
-
-VALUE
-rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
-{
-    switch (type) {
-        case VOID:
-            return Qnil;        
-        case INT8:
-            return INT2NUM(*(char *) ptr);
-        case INT16:
-            return INT2NUM(*(short *) ptr);
-        case INT32:
-            return INT2NUM(*(int *) ptr);
-        case UINT8:
-            return UINT2NUM(*(unsigned char *) ptr);
-        case UINT16:
-            return UINT2NUM(*(unsigned short *) ptr);
-        case UINT32:
-            return UINT2NUM(*(unsigned int *) ptr);
-        case INT64:
-            return LL2NUM(*(signed long long *) ptr);
-        case UINT64:
-            return ULL2NUM(*(unsigned long long *) ptr);
-        case FLOAT32:
-            return rb_float_new(*(float *) ptr);
-        case FLOAT64:
-            return rb_float_new(*(double *) ptr);
-        case STRING:
-            return rb_tainted_str_new2(*(char **) ptr);
-        case POINTER:
-            return rb_FFI_Pointer_new(*(void **) ptr);
-        default:
-            rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
-    }
-}

data/ext/ffi.c

@@ -1,64 +0,0 @@
-#include <sys/types.h>
-#include <stdio.h>
-#include <dlfcn.h>
-#include <ruby.h>
-
-#include <ffi.h>
-
-#include "rbffi.h"
-#include "AbstractMemory.h"
-#include "Pointer.h"
-#include "MemoryPointer.h"
-#include "AutoPointer.h"
-#include "NativeLibrary.h"
-#include "Platform.h"
-#include "Types.h"
-
-
-void Init_ffi();
-
-static VALUE moduleFFI = Qnil;
-static VALUE moduleNativeType = Qnil;
-
-void
-Init_ffi_c() {
-    moduleFFI = rb_define_module("FFI");
-    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
-    
-    rb_define_const(moduleNativeType, "VOID", INT2FIX(VOID));
-    rb_define_const(moduleNativeType, "INT8", INT2FIX(INT8));
-    rb_define_const(moduleNativeType, "UINT8", INT2FIX(UINT8));
-    rb_define_const(moduleNativeType, "INT16", INT2FIX(INT16));
-    rb_define_const(moduleNativeType, "UINT16", INT2FIX(UINT16));
-    rb_define_const(moduleNativeType, "INT32", INT2FIX(INT32));
-    rb_define_const(moduleNativeType, "UINT32", INT2FIX(UINT32));
-    rb_define_const(moduleNativeType, "INT64", INT2FIX(INT64));
-    rb_define_const(moduleNativeType, "UINT64", INT2FIX(UINT64));
-    rb_define_const(moduleNativeType, "FLOAT32", INT2FIX(FLOAT32));
-    rb_define_const(moduleNativeType, "FLOAT64", INT2FIX(FLOAT64));
-    rb_define_const(moduleNativeType, "POINTER", INT2FIX(POINTER));
-    rb_define_const(moduleNativeType, "STRING", INT2FIX(STRING));
-    rb_define_const(moduleNativeType, "RBXSTRING", INT2FIX(RBXSTRING));
-    rb_define_const(moduleNativeType, "CHAR_ARRAY", INT2FIX(CHAR_ARRAY));
-    rb_define_const(moduleNativeType, "BUFFER_IN", INT2FIX(BUFFER_IN));
-    rb_define_const(moduleNativeType, "BUFFER_OUT", INT2FIX(BUFFER_OUT));
-    rb_define_const(moduleNativeType, "BUFFER_INOUT", INT2FIX(BUFFER_INOUT));
-    rb_define_const(moduleNativeType, "VARARGS", INT2FIX(VARARGS));
-    if (sizeof(long) == 4) {
-        rb_define_const(moduleNativeType, "LONG", INT2FIX(INT32));
-        rb_define_const(moduleNativeType, "ULONG", INT2FIX(UINT32));
-    } else {
-        rb_define_const(moduleNativeType, "LONG", INT2FIX(INT64));
-        rb_define_const(moduleNativeType, "ULONG", INT2FIX(UINT64));
-    }
-    rb_FFI_Platform_Init();
-    rb_FFI_AbstractMemory_Init();
-    rb_FFI_Pointer_Init();
-    rb_FFI_AutoPointer_Init();
-    rb_FFI_MemoryPointer_Init();
-    rb_FFI_Buffer_Init();
-    rb_FFI_Callback_Init();
-    rb_FFI_NativeLibrary_Init();
-    rb_FFI_Invoker_Init();
-}
-

data/ext/ffi.mk

@@ -1,24 +0,0 @@
-# -*- makefile -*-
-
-CFLAGS += -Werror -Wformat
-INCFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
-CPPFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
-LOCAL_LIBS += $(LIBFFI) -lpthread
-
-FFI_MMAP_EXEC = -DFFI_MMAP_EXEC_WRIT
-FFI_CFLAGS = $(FFI_MMAP_EXEC) $(OFLAGS)
-BUILD_DIR = $(PWD)/build
-LIBFFI_SRC_DIR = $(PWD)/$(srcdir)/libffi
-LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
-LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a
-FFI_CONFIGURE = sh $(LIBFFI_SRC_DIR)/configure --disable-static \
-	--with-pic=yes --disable-dependency-tracking
-
-$(OBJS):	$(LIBFFI)
-
-clean:	libffi_clean
-
-libffi_clean::
-	$(RM) -r $(BUILD_DIR)
-
-