ffi 0.4.0-x86-mswin32

data/ext/ffi_c/LastError.c

@@ -0,0 +1,135 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ruby.h>
+
+#include "LastError.h"
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+# include <pthread.h>
+#endif
+
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+#  define USE_PTHREAD_LOCAL
+#endif
+
+typedef struct ThreadData {
+    int td_errno;
+} ThreadData;
+
+#if defined(USE_PTHREAD_LOCAL)
+static pthread_key_t threadDataKey;
+#endif
+
+static inline ThreadData* thread_data_get(void);
+
+#if defined(USE_PTHREAD_LOCAL)
+
+static ThreadData*
+thread_data_init(void)
+{
+    ThreadData* td = ALLOC_N(ThreadData, 1);
+
+    memset(td, 0, sizeof(*td));
+    pthread_setspecific(threadDataKey, td);
+
+    return td;
+}
+
+
+static inline ThreadData*
+thread_data_get(void)
+{
+    ThreadData* td = pthread_getspecific(threadDataKey);
+    return td != NULL ? td : thread_data_init();
+}
+
+static void
+thread_data_free(void *ptr)
+{
+    xfree(ptr);
+}
+
+#else
+static ID id_thread_data;
+
+static ThreadData*
+thread_data_init(void)
+{
+    ThreadData* td;
+    VALUE obj;
+
+    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
+    rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);
+
+    return td;
+}
+
+static inline ThreadData*
+thread_data_get()
+{
+    VALUE obj = rb_thread_local_aref(rb_thread_current(), id_thread_data);
+
+    if (obj != Qnil && TYPE(obj) == T_DATA) {
+        return (ThreadData *) DATA_PTR(obj);
+    }
+
+    return thread_data_init();
+}
+
+#endif
+
+
+static VALUE
+get_last_error(VALUE self)
+{
+    return INT2NUM(thread_data_get()->td_errno);
+}
+
+
+static VALUE
+set_last_error(VALUE self, VALUE error)
+{
+
+#ifdef _WIN32
+    SetLastError(NUM2INT(error));
+#else
+    errno = NUM2INT(error);
+#endif
+
+    return Qnil;
+}
+
+
+void
+rbffi_save_errno(void)
+{
+    int error = 0;
+
+#ifdef _WIN32
+    error = GetLastError();
+#else
+    error = errno;
+#endif
+
+    thread_data_get()->td_errno = error;
+}
+
+
+void
+rbffi_LastError_Init(VALUE moduleFFI)
+{
+    VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
+
+    rb_define_module_function(moduleError, "error", get_last_error, 0);
+    rb_define_module_function(moduleError, "error=", set_last_error, 1);
+
+#if defined(USE_PTHREAD_LOCAL)
+    pthread_key_create(&threadDataKey, thread_data_free);
+#else
+    id_thread_data = rb_intern("ffi_thread_local_data");
+#endif /* USE_PTHREAD_LOCAL */
+}

data/ext/ffi_c/LastError.h

@@ -0,0 +1,18 @@
+#ifndef RBFFI_LASTERROR_H
+#define	RBFFI_LASTERROR_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+void rbffi_LastError_Init(VALUE moduleFFI);
+
+void rbffi_save_errno(void);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_LASTERROR_H */
+

data/ext/ffi_c/MemoryPointer.c

@@ -0,0 +1,156 @@
+#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 rbffi_MemoryPointerClass;
+
+#define MEMPTR(obj) ((MemoryPointer *) rbffi_AbstractMemory_Cast(obj, rbffi_MemoryPointerClass))
+
+static ID plus_id = 0;
+
+VALUE
+rbffi_MemoryPointer_NewInstance(long size, long count, bool clear)
+{
+    return memptr_malloc(memptr_allocate(rbffi_MemoryPointerClass), size, count, clear);
+}
+
+static VALUE
+memptr_allocate(VALUE klass)
+{
+    MemoryPointer* p;
+    VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+
+    return obj;
+}
+
+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, rbffi_type_size(size), nargs > 1 ? NUM2LONG(count) : 1,
+        RTEST(clear) || clear == Qnil);
+    
+    if (rb_block_given_p()) {
+        return rb_ensure(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, plus_id, 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
+rbffi_MemoryPointer_Init(VALUE moduleFFI)
+{
+    rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_MemoryPointerClass);
+
+    rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
+    rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
+    rb_define_method(rbffi_MemoryPointerClass, "inspect", memptr_inspect, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "autorelease=", memptr_autorelease, 1);
+    rb_define_method(rbffi_MemoryPointerClass, "free", memptr_free, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "type_size", memptr_type_size, 0);
+    rb_define_method(rbffi_MemoryPointerClass, "[]", memptr_aref, 1);
+    
+    plus_id = rb_intern("+");
+}

data/ext/ffi_c/MemoryPointer.h

@@ -0,0 +1,20 @@
+
+#ifndef _MEMORYPOINTER_H
+#define	_MEMORYPOINTER_H
+
+#include <stdbool.h>
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    extern void rbffi_MemoryPointer_Init(VALUE moduleFFI);
+    extern VALUE rbffi_MemoryPointerClass;
+    extern VALUE rbffi_MemoryPointer_NewInstance(long size, long count, bool clear);
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _MEMORYPOINTER_H */
+

data/ext/ffi_c/NullPointer.c

@@ -0,0 +1,143 @@
+#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 NullPointerErrorClass;
+
+VALUE rbffi_NullPointerClass;
+VALUE rbffi_NullPointerSingleton;
+
+static VALUE
+nullptr_allocate(VALUE klass)
+{
+    AbstractMemory* p;
+    VALUE retval;
+
+    retval = Data_Make_Struct(klass, AbstractMemory, NULL, -1, p);
+    p->address = 0;
+    p->size = 0;
+    p->ops = &rbffi_NullPointerOps;
+
+    return retval;
+}
+
+static VALUE
+nullptr_op(int argc, VALUE* argv, VALUE self)
+{
+    rb_raise(NullPointerErrorClass, "NULL Pointer access attempted");
+    return Qnil;
+}
+
+static VALUE
+nullptr_op_get(AbstractMemory* ptr, long offset)
+{
+    rb_raise(NullPointerErrorClass, "NULL Pointer access attempted");
+    return Qnil;
+}
+
+static void
+nullptr_op_put(AbstractMemory* ptr, long offset, VALUE value)
+{
+    rb_raise(NullPointerErrorClass, "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, rbffi_PointerClass)) {
+        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);
+}
+
+static MemoryOp NullPointerMemoryOp = { nullptr_op_get, nullptr_op_put };
+
+MemoryOps rbffi_NullPointerOps = {
+    .int8 = &NullPointerMemoryOp,
+    .uint8 = &NullPointerMemoryOp,
+    .int16 = &NullPointerMemoryOp,
+    .int16 = &NullPointerMemoryOp,
+    .int32 = &NullPointerMemoryOp,
+    .uint32 = &NullPointerMemoryOp,
+    .int64 = &NullPointerMemoryOp,
+    .uint64 = &NullPointerMemoryOp,
+    .float32 = &NullPointerMemoryOp,
+    .float64 = &NullPointerMemoryOp,
+    .pointer = &NullPointerMemoryOp,
+    .strptr = &NullPointerMemoryOp,
+};
+
+void
+rbffi_NullPointer_Init(VALUE moduleFFI)
+{
+    rbffi_NullPointerClass = rb_define_class_under(moduleFFI, "NullPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_NullPointerClass);
+    
+    NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
+    rb_global_variable(&NullPointerErrorClass);
+
+    rb_define_alloc_func(rbffi_NullPointerClass, nullptr_allocate);
+    rb_define_method(rbffi_NullPointerClass, "inspect", nullptr_inspect, 0);
+    rb_define_method(rbffi_NullPointerClass, "+", nullptr_op, -1);
+    rb_define_method(rbffi_NullPointerClass, "null?", nullptr_null_p, 0);
+    rb_define_method(rbffi_NullPointerClass, "address", nullptr_address, 0);
+    rb_define_method(rbffi_NullPointerClass, "==", nullptr_equals, 1);
+
+#define NOP(name) \
+    rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "get_array_of_" #name, nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "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(rbffi_NullPointerClass, "get_" #name, nullptr_op,  -1); \
+    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1);
+
+    NOP(string); NOP(bytes); NOP(pointer); NOP(callback);
+
+    rb_define_method(rbffi_NullPointerClass, "clear", nullptr_op, -1); \
+    rb_define_method(rbffi_NullPointerClass, "total", nullptr_op, -1);
+
+    // Create a singleton instance of NullPointer that can be shared
+    rbffi_NullPointerSingleton = nullptr_allocate(rbffi_NullPointerClass);
+    rb_global_variable(&rbffi_NullPointerSingleton);
+    rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
+}
+