ffi 1.0.9 → 1.0.10

data/ext/ffi_c/MemoryPointer.c

@@ -88,7 +88,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
         return Qnil;
     }
     p->autorelease = true;
-    p->memory.typeSize = size;
+    p->memory.typeSize = (int) size;
     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);;
@@ -135,6 +135,15 @@ memptr_mark(Pointer* ptr)
     rb_gc_mark(ptr->rbParent);
 }
 
+static VALUE
+memptr_s_from_string(VALUE klass, VALUE s)
+{
+    VALUE args[] = { INT2FIX(1), LONG2NUM(RSTRING_LEN(s) + 1), Qfalse };
+    VALUE obj = rb_class_new_instance(3, args, klass);
+    rb_funcall(obj, rb_intern("put_string"), 2, INT2FIX(0), s);
+    
+    return obj;
+}
 
 void
 rbffi_MemoryPointer_Init(VALUE moduleFFI)
@@ -144,5 +153,6 @@ rbffi_MemoryPointer_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
     rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
+    rb_define_singleton_method(rbffi_MemoryPointerClass, "from_string", memptr_s_from_string, 1);
 }
 

data/ext/ffi_c/MethodHandle.c

@@ -67,7 +67,7 @@
 
 
 static bool prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
-static int trampoline_size(void);
+static long trampoline_size(void);
 
 #if defined(__x86_64__) && defined(__GNUC__)
 # define CUSTOM_TRAMPOLINE 1
@@ -143,14 +143,14 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 }
 
 
-static int
+static long
 trampoline_size(void)
 {
     return sizeof(METHOD_CLOSURE);
 }
 
 /*
- * attached_method_vinvoke is used functions with more than 6 parameters, or
+ * attached_method_invoke is used functions with more than 6 parameters, or
  * with struct param or return values
  */
 static void
@@ -211,7 +211,13 @@ static VALUE
 custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
-    return (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+    VALUE rbReturnValue;
+    
+    RB_GC_GUARD(rbReturnValue) = (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
+    RB_GC_GUARD_PTR(argv);
+    RB_GC_GUARD(self);
+
+    return rbReturnValue;
 }
 
 #elif defined(__i386__) && 0
@@ -258,11 +264,11 @@ custom_trampoline(caddr_t args, Closure* handle)
 
 extern void ffi_trampoline(int argc, VALUE* argv, VALUE self);
 extern void ffi_trampoline_end(void);
-static int trampoline_offsets(int *, int *);
+static int trampoline_offsets(long *, long *);
 
-static int trampoline_ctx_offset, trampoline_func_offset;
+static long trampoline_ctx_offset, trampoline_func_offset;
 
-static int
+static long
 trampoline_offset(int off, const long value)
 {
     caddr_t ptr;
@@ -276,7 +282,7 @@ trampoline_offset(int off, const long value)
 }
 
 static int
-trampoline_offsets(int* ctxOffset, int* fnOffset)
+trampoline_offsets(long* ctxOffset, long* fnOffset)
 {
     *ctxOffset = trampoline_offset(0, TRAMPOLINE_CTX_MAGIC);
     if (*ctxOffset == -1) {
@@ -304,7 +310,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
     return true;
 }
 
-static int
+static long
 trampoline_size(void)
 {
     return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
@@ -316,14 +322,15 @@ trampoline_size(void)
 void
 rbffi_MethodHandle_Init(VALUE module)
 {
-    defaultClosurePool = rbffi_ClosurePool_New(trampoline_size(), prep_trampoline, NULL);
+    ffi_status ffiStatus;
+    defaultClosurePool = rbffi_ClosurePool_New((int) trampoline_size(), prep_trampoline, NULL);
 
 #if defined(CUSTOM_TRAMPOLINE)
     if (trampoline_offsets(&trampoline_ctx_offset, &trampoline_func_offset) != 0) {
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
-    ffi_status ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
+    ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {
         rb_raise(rb_eFatal, "ffi_prep_cif failed.  status=%#x", ffiStatus);

data/ext/ffi_c/Platform.c

@@ -26,6 +26,9 @@
 #include <ctype.h>
 #include "endian.h"
 #include "Platform.h"
+#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
+  #include <gnu/lib-names.h>
+#endif
 
 static VALUE PlatformModule = Qnil;
 
@@ -34,13 +37,13 @@ static VALUE PlatformModule = Qnil;
  * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
  * on intel.
  */
-#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64)
+#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64) || defined(_M_X64) || defined(_M_AMD64)
 # define CPU "x86_64"
 
-#elif defined(__i386__) || defined(__i386)
+#elif defined(__i386__) || defined(__i386) || defined(_M_IX86)
 # define CPU "i386"
 
-#elif defined(__ppc64__) || defined(__powerpc64__)
+#elif defined(__ppc64__) || defined(__powerpc64__) || defined(_M_PPC)
 # define CPU "ppc64"
 
 #elif defined(__ppc__) || defined(__powerpc__) || defined(__powerpc)
@@ -93,6 +96,9 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
     rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
+#if defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)
+    rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
+#endif
     export_primitive_types(PlatformModule);
 }
 

data/ext/ffi_c/Pointer.c

@@ -68,6 +68,17 @@ ptr_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * @overload initialize(pointer)
+ *  @param [Pointer] pointer another pointer to initialize from
+ *  Create a new pointer from another {Pointer}.
+ * @overload initialize(type, address)
+ *  @param [Type] type type for pointer
+ *  @param [Integer] address base address for pointer
+ *  Create a new pointer from a {Type} and a base adresse
+ * @return [self]
+ * A new instance of Pointer.
+ */
 static VALUE
 ptr_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -117,6 +128,16 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: ptr.initialize_copy(other)
+ * @param [Pointer] other source for cloning or dupping
+ * @return [self]
+ * @raise {RuntimeError} if +other+ is an unbounded memory area, or is unreable/unwritable
+ * @raise {NoMemError} if failed to allocate memory for new object
+ * DO NOT CALL THIS METHOD.
+ *
+ * This method is internally used by #dup and #clone. Memory contents is copied from +other+.
+ */
 static VALUE
 ptr_initialize_copy(VALUE self, VALUE other)
 {
@@ -179,6 +200,13 @@ slice(VALUE self, long offset, long size)
     return retval;
 }
 
+/* 
+ * Document-method: +
+ * call-seq: ptr + offset
+ * @param [Numeric] offset
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing pointer and an +offset+.
+ */
 static VALUE
 ptr_plus(VALUE self, VALUE offset)
 {
@@ -190,12 +218,25 @@ ptr_plus(VALUE self, VALUE offset)
     return slice(self, off, ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off);
 }
 
+/*
+ * call-seq: ptr.slice(offset, length)
+ * @param [Numeric] offset
+ * @param [Numeric] length
+ * @return [Pointer]
+ * Return a new {Pointer} from an existing one. This pointer points on same contents 
+ * from +offset+ for a length +length+.
+ */
 static VALUE
 ptr_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
 {
     return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
 }
 
+/*
+ * call-seq: ptr.inspect
+ * @return [String]
+ * Inspect pointer object.
+ */
 static VALUE
 ptr_inspect(VALUE self)
 {
@@ -214,6 +255,12 @@ ptr_inspect(VALUE self)
     return rb_str_new2(buf);
 }
 
+/*
+ * Document-method: null?
+ * call-seq: ptr.null?
+ * @return [Boolean]
+ * Return +true+ if +self+ is a {NULL} pointer.
+ */
 static VALUE
 ptr_null_p(VALUE self)
 {
@@ -224,6 +271,12 @@ ptr_null_p(VALUE self)
     return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
+/*
+ * Document-method: ==
+ * call-seq: ptr == other
+ * @param [Pointer] other
+ * Check equality between +self+ and +other+. Equality is tested on {#address}.
+ */
 static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
@@ -234,6 +287,11 @@ ptr_equals(VALUE self, VALUE other)
     return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq: ptr.address
+ * @return [Numeric] pointer's base address
+ * Return +self+'s base address (alias: #to_i).
+ */
 static VALUE
 ptr_address(VALUE self)
 {
@@ -250,6 +308,15 @@ ptr_address(VALUE self)
 # define SWAPPED_ORDER LITTLE_ENDIAN
 #endif
 
+/*
+ * Get or set +self+'s endianness
+ * @overload ptr.order
+ *  @return [:big, :little] endianness of +self+
+ * @overload ptr.order(order)
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+ 
+ *   are synonymous.
+ *  @return [self]
+ */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
 {
@@ -289,6 +356,11 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 }
 
 
+/*
+ * call-seq: ptr.free
+ * @return [self]
+ * Free memory pointed by +self+.
+ */
 static VALUE
 ptr_free(VALUE self)
 {
@@ -307,6 +379,12 @@ ptr_free(VALUE self)
     return self;
 }
 
+/*
+ * call-seq: ptr.autorelease = autorelease
+ * @param [Boolean] autorelease
+ * @return [Boolean] +autorelease+
+ * Set +autorelease+ attribute. See also Autorelease section.
+ */
 static VALUE
 ptr_autorelease(VALUE self, VALUE autorelease)
 {
@@ -318,6 +396,11 @@ ptr_autorelease(VALUE self, VALUE autorelease)
     return autorelease;
 }
 
+/*
+ * call-seq: ptr.autorelease?
+ * @return [Boolean]
+ * Get +autorelease+ attribute. See also Autorelease section.
+ */
 static VALUE
 ptr_autorelease_p(VALUE self)
 {
@@ -350,7 +433,19 @@ rbffi_Pointer_Init(VALUE moduleFFI)
 {
     VALUE rbNullAddress = ULL2NUM(0);
 
+    /* 
+     * Document-class: FFI::Pointer < FFI::AbstractMemory
+     * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
+     * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
+     *
+     * ==Autorelease
+     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
+     * changed with {#autorelease=} method.
+     */
     rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
+    /*
+     * Document-variable: Pointer
+     */
     rb_global_variable(&rbffi_PointerClass);
 
     rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
@@ -370,6 +465,9 @@ rbffi_Pointer_Init(VALUE moduleFFI)
     rb_define_method(rbffi_PointerClass, "free", ptr_free, 0);
 
     rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
+    /*
+     * NULL pointer
+     */
     rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
 }
 

data/ext/ffi_c/Struct.c

@@ -47,7 +47,7 @@ typedef struct InlineArray_ {
     MemoryOp *op;
     Type* componentType;
     ArrayType* arrayType;
-    unsigned int length;
+    int length;
 } InlineArray;
 
 
@@ -97,7 +97,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
 
     /* Call up into ruby code to adjust the layout */
     if (nargs > 1) {
-        s->rbLayout = rb_funcall2(CLASS_OF(self), id_layout, RARRAY_LEN(rest), RARRAY_PTR(rest));
+        s->rbLayout = rb_funcall2(CLASS_OF(self), id_layout, (int) RARRAY_LEN(rest), RARRAY_PTR(rest));
     } else {
         s->rbLayout = struct_class_layout(klass);
     }
@@ -354,7 +354,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
     Data_Get_Struct(pointer, AbstractMemory, memory);
     layout = struct_layout(self);
 
-    if (layout->base.ffiType->size > memory->size) {
+    if ((int) layout->base.ffiType->size > memory->size) {
         rb_raise(rb_eArgError, "memory of %ld bytes too small for struct %s (expected at least %ld)",
                 memory->size, rb_obj_classname(self), (long) layout->base.ffiType->size);
     }
@@ -495,7 +495,7 @@ inline_array_offset(InlineArray* array, int index)
         rb_raise(rb_eIndexError, "index %d out of bounds", index);
     }
 
-    return array->field->offset + (index * array->componentType->ffiType->size);
+    return (int) array->field->offset + (index * (int) array->componentType->ffiType->size);
 }
 
 static VALUE

data/ext/ffi_c/Struct.h

@@ -22,6 +22,7 @@
 #ifndef RBFFI_STRUCT_H
 #define	RBFFI_STRUCT_H
 
+#include "extconf.h"
 #include "AbstractMemory.h"
 #include "Type.h"
 #ifdef RUBY_1_9
@@ -59,7 +60,7 @@ extern "C" {
     struct StructLayout_ {
         Type base;
         StructField** fields;
-        unsigned int fieldCount;
+        int fieldCount;
         int size;
         int align;
         ffi_type** ffiTypes;

data/ext/ffi_c/StructLayout.c

@@ -348,7 +348,7 @@ struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
     int i;
 
     Data_Get_Struct(self, StructLayout, layout);
-    layout->fieldCount = RARRAY_LEN(fields);
+    layout->fieldCount = (int) RARRAY_LEN(fields);
     layout->rbFieldMap = rb_hash_new();
     layout->rbFieldNames = rb_ary_new2(layout->fieldCount);
     layout->size = NUM2INT(size);
@@ -374,8 +374,8 @@ struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
         }
         rbName = rb_funcall2(rbField, rb_intern("name"), 0, NULL);
 
-        field = layout->fields[i];
         Data_Get_Struct(rbField, StructField, field);
+        layout->fields[i] = field;
 
         if (field->type == NULL || field->type->ffiType == NULL) {
             rb_raise(rb_eRuntimeError, "type of field %d not supported", i);

data/ext/ffi_c/Thread.c

@@ -25,6 +25,7 @@
 # include <errno.h>
 # include <signal.h>
 #else
+# define _WINSOCKAPI_
 # include <windows.h>
 #endif
 #include <fcntl.h>
@@ -179,6 +180,113 @@ rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(voi
 }
 
 #else
+/* win32 implementation */
+
+struct BlockingThread {
+    HANDLE tid;
+    VALUE (*fn)(void *);
+    void *data;
+    void (*ubf)(void *);
+    void *data2;
+    VALUE retval;
+    int wrfd;
+    int rdfd;
+};
+
+static DWORD __stdcall
+rbffi_blocking_thread(LPVOID args)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) args;
+    char c = 1;
+    VALUE retval;
+
+    retval = (*thr->fn)(thr->data);
+    thr->retval = retval;
+
+    write(thr->wrfd, &c, sizeof(c));
+
+    return 0;
+}
+
+static VALUE
+wait_for_thread(void *data)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) data;
+    char c, res;
+    fd_set rfds;
+
+    FD_ZERO(&rfds);
+    FD_SET(thr->rdfd, &rfds);
+    rb_thread_select(thr->rdfd + 1, &rfds, NULL, NULL, NULL);
+    read(thr->rdfd, &c, 1);
+    return Qnil;
+}
+
+static VALUE
+cleanup_blocking_thread(void *data, VALUE exc)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) data;
+
+    if (thr->ubf != (void (*)(void *)) -1) {
+        (*thr->ubf)(thr->data2);
+    } else {
+        TerminateThread(thr->tid, 0);
+    }
+
+    return exc;
+}
+
+VALUE
+rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(void *), void *data2)
+{
+    struct BlockingThread* thr;
+    int fd[2];
+    VALUE exc;
+    DWORD state;
+    DWORD res;
+
+    if (_pipe(fd, 1024, O_BINARY) == -1) {
+        rb_raise(rb_eSystemCallError, "_pipe() failed");
+        return Qnil;
+    }
+
+    thr = ALLOC_N(struct BlockingThread, 1);
+    thr->rdfd = fd[0];
+    thr->wrfd = fd[1];
+    thr->fn = func;
+    thr->data = data1;
+    thr->ubf = ubf;
+    thr->data2 = data2;
+    thr->retval = Qnil;
+
+    thr->tid = CreateThread(NULL, 0, rbffi_blocking_thread, thr, 0, NULL);
+    if (!thr->tid) {
+        close(fd[0]);
+        close(fd[1]);
+        xfree(thr);
+        rb_raise(rb_eSystemCallError, "CreateThread() failed");
+        return Qnil;
+    }
+
+    exc = rb_rescue2(wait_for_thread, (VALUE) thr, cleanup_blocking_thread, (VALUE) thr,
+        rb_eException);
+
+    /* The thread should be finished, already. */
+    WaitForSingleObject(thr->tid, INFINITE);
+    CloseHandle(thr->tid);
+    close(fd[1]);
+    close(fd[0]);
+    xfree(thr);
+
+    if (exc != Qnil) {
+        rb_exc_raise(exc);
+    }
+
+    return thr->retval;
+}
+
+
+#if 0
 
 /*
  * FIXME: someone needs to implement something similar to the posix pipe based
@@ -187,8 +295,23 @@ rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(voi
 VALUE
 rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(void *), void *data2)
 {
-    return (*func)(data1);
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+    rbffi_thread_t oldThread;
+#endif
+    VALUE res;
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+    oldThread = rbffi_active_thread;
+    rbffi_active_thread = rbffi_thread_self();
+#endif
+
+    res = (*func)(data1);
+
+#if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
+    rbffi_active_thread = oldThread;
+#endif
+  return res;
 }
+#endif
 
 #endif /* !_WIN32 */