ffi 1.0.9-x86-mingw32 → 1.0.12.pre-x86-mingw32

data/ext/ffi_c/AbstractMemory.h

@@ -21,9 +21,13 @@
 #ifndef RBFFI_ABSTRACTMEMORY_H
 #define	RBFFI_ABSTRACTMEMORY_H
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
+#ifndef _MSC_VER
 #include <stdint.h>
+#endif
 
 #include "compat.h"
 #include "Types.h"
@@ -37,6 +41,7 @@ extern "C" {
 #define MEM_WR   0x02
 #define MEM_CODE 0x04
 #define MEM_SWAP 0x08
+#define MEM_EMBED 0x10
 
 typedef struct AbstractMemory_ AbstractMemory;
 
@@ -60,6 +65,7 @@ typedef struct {
     MemoryOp* float64;
     MemoryOp* pointer;
     MemoryOp* strptr;
+    MemoryOp* boolOp;
 } MemoryOps;
 
 struct AbstractMemory_ {
@@ -136,6 +142,8 @@ get_memory_op(Type* type)
             return rbffi_AbstractMemoryOps.pointer;
         case NATIVE_STRING:
             return rbffi_AbstractMemoryOps.strptr;
+        case NATIVE_BOOL:
+            return rbffi_AbstractMemoryOps.boolOp;
         default:
             return NULL;
     }

data/ext/ffi_c/ArrayType.c

@@ -62,6 +62,13 @@ array_type_free(ArrayType *array)
 }
 
 
+/*
+ * call-seq: initialize(component_type, length)
+ * @param [Type] component_type
+ * @param [Numeric] length
+ * @return [self]
+ * A new instance of ArrayType.
+ */
 static VALUE
 array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength)
 {
@@ -86,6 +93,11 @@ array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength)
     return self;
 }
 
+/*
+ * call-seq: length
+ * @return [Numeric]
+ * Get array's length
+ */
 static VALUE
 array_type_length(VALUE self)
 {
@@ -96,6 +108,11 @@ array_type_length(VALUE self)
     return UINT2NUM(array->length);
 }
 
+/*
+ * call-seq: element_type
+ * @return [Type]
+ * Get element type.
+ */
 static VALUE
 array_type_element_type(VALUE self)
 {
@@ -109,8 +126,19 @@ array_type_element_type(VALUE self)
 void
 rbffi_ArrayType_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-class: FFI::ArrayType < FFI::Type
+     *
+     * This is a typed array. The type is a {NativeType native type}.
+     */
     rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", rbffi_TypeClass);
+    /*
+     * Document-variable: FFI::ArrayType
+     */
     rb_global_variable(&rbffi_ArrayTypeClass);
+    /*
+     * Document-constant: FFI::Type::Array
+     */
     rb_define_const(rbffi_TypeClass, "Array", rbffi_ArrayTypeClass);
 
     rb_define_alloc_func(rbffi_ArrayTypeClass, array_type_s_allocate);

data/ext/ffi_c/Buffer.c

@@ -18,18 +18,31 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
+#ifndef _MSC_VER
 #include <stdint.h>
+#endif
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
 #include "endian.h"
 #include "AbstractMemory.h"
 
+#define BUFFER_EMBED_MAXLEN (8)
 typedef struct Buffer {
     AbstractMemory memory;
-    char* storage; /* start of malloc area */
-    VALUE rbParent;
+    
+    union {
+        VALUE rbParent; /* link to parent buffer */
+        char* storage; /* start of malloc area */
+        long embed[BUFFER_EMBED_MAXLEN / sizeof(long)]; // storage for tiny allocations
+    } data;
 } Buffer;
 
 static VALUE buffer_allocate(VALUE klass);
@@ -47,7 +60,7 @@ buffer_allocate(VALUE klass)
     VALUE obj;
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
-    buffer->rbParent = Qnil;
+    buffer->data.rbParent = Qnil;
     buffer->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
@@ -56,14 +69,23 @@ buffer_allocate(VALUE klass)
 static void
 buffer_release(Buffer* ptr)
 {
-    if (ptr->storage != NULL) {
-        xfree(ptr->storage);
-        ptr->storage = NULL;
+    if ((ptr->memory.flags & MEM_EMBED) == 0 && ptr->data.storage != NULL) {
+        xfree(ptr->data.storage);
+        ptr->data.storage = NULL;
     }
     
     xfree(ptr);
 }
 
+/*
+ * call-seq: initialize(size, count=1, clear=false)
+ * @param [Integer, Symbol, #size] Type or size in bytes of a buffer cell
+ * @param [Fixnum] count number of cell in the Buffer
+ * @param [Boolean] clear if true, set the buffer to all-zero
+ * @return [self]
+ * @raise {NoMemoryError} if failed to allocate memory for Buffer
+ * A new instance of Buffer.
+ */
 static VALUE
 buffer_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -77,17 +99,23 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     p->memory.typeSize = rbffi_type_size(rbSize);
     p->memory.size = p->memory.typeSize * (nargs > 1 ? NUM2LONG(rbCount) : 1);
 
-    p->storage = xmalloc(p->memory.size + 7);
-    if (p->storage == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
-        return Qnil;
-    }
+    if (p->memory.size > BUFFER_EMBED_MAXLEN) {
+        p->data.storage = xmalloc(p->memory.size + 7);
+        if (p->data.storage == NULL) {
+            rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
+            return Qnil;
+        }
 
-    /* ensure the memory is aligned on at least a 8 byte boundary */
-    p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
+        /* ensure the memory is aligned on at least a 8 byte boundary */
+        p->memory.address = (void *) (((uintptr_t) p->data.storage + 0x7) & (uintptr_t) ~0x7UL);
+    
+        if (p->memory.size > 0 && (nargs < 3 || RTEST(rbClear))) {
+            memset(p->memory.address, 0, p->memory.size);
+        }
     
-    if (nargs > 2 && (RTEST(rbClear) || rbClear == Qnil) && p->memory.size > 0) {
-        memset(p->memory.address, 0, p->memory.size);
+    } else {
+        p->memory.flags |= MEM_EMBED;
+        p->memory.address = (void *) &p->data.embed[0];
     }
 
     if (rb_block_given_p()) {
@@ -97,6 +125,11 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: initialize_copy(other)
+ * @return [self]
+ * DO NOT CALL THIS METHOD.
+ */
 static VALUE
 buffer_initialize_copy(VALUE self, VALUE other)
 {
@@ -105,16 +138,16 @@ buffer_initialize_copy(VALUE self, VALUE other)
     
     Data_Get_Struct(self, Buffer, dst);
     src = rbffi_AbstractMemory_Cast(other, BufferClass);
-    if (dst->storage != NULL) {
-        xfree(dst->storage);
+    if ((dst->memory.flags & MEM_EMBED) == 0 && dst->data.storage != NULL) {
+        xfree(dst->data.storage);
     }
-    dst->storage = xmalloc(src->size + 7);
-    if (dst->storage == NULL) {
+    dst->data.storage = xmalloc(src->size + 7);
+    if (dst->data.storage == NULL) {
         rb_raise(rb_eNoMemError, "failed to allocate memory size=%lu bytes", src->size);
         return Qnil;
     }
     
-    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->data.storage + 0x7) & (uintptr_t) ~0x7UL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
     
@@ -145,11 +178,17 @@ slice(VALUE self, long offset, long len)
     result->memory.size = len;
     result->memory.flags = ptr->memory.flags;
     result->memory.typeSize = ptr->memory.typeSize;
-    result->rbParent = self;
+    result->data.rbParent = self;
 
     return obj;
 }
 
+/*
+ * call-seq: + offset
+ * @param [Numeric] offset
+ * @return [Buffer] a new instance of Buffer pointing from offset until end of previous buffer.
+ * Add a Buffer with an offset
+ */
 static VALUE
 buffer_plus(VALUE self, VALUE rbOffset)
 {
@@ -161,12 +200,24 @@ buffer_plus(VALUE self, VALUE rbOffset)
     return slice(self, offset, ptr->memory.size - offset);
 }
 
+/*
+ * call-seq: slice(offset, length)
+ * @param [Numeric] offset
+ * @param [Numeric] length
+ * @return [Buffer] a new instance of Buffer
+ * Slice an existing Buffer.
+ */
 static VALUE
 buffer_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
 {
     return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
 }
 
+/*
+ * call-seq: inspect
+ * @return [String]
+ * Inspect a Buffer.
+ */
 static VALUE
 buffer_inspect(VALUE self)
 {
@@ -187,6 +238,16 @@ buffer_inspect(VALUE self)
 # define SWAPPED_ORDER LITTLE_ENDIAN
 #endif
 
+/*
+ * Set or get endianness of Buffer.
+ * @overload order
+ *  @return [:big, :little]
+ *  Get endianness of Buffer.
+ * @overload order(order)
+ *  @param [:big, :little, :network] order
+ *  @return [self]
+ *  Set endinaness of Buffer (+:network+ is an alias for +:big+).
+ */
 static VALUE
 buffer_order(int argc, VALUE* argv, VALUE self)
 {
@@ -232,9 +293,9 @@ buffer_free(VALUE self)
     Buffer* ptr;
 
     Data_Get_Struct(self, Buffer, ptr);
-    if (ptr->storage != NULL) {
-        xfree(ptr->storage);
-        ptr->storage = NULL;
+    if ((ptr->memory.flags & MEM_EMBED) == 0 && ptr->data.storage != NULL) {
+        xfree(ptr->data.storage);
+        ptr->data.storage = NULL;
     }
 
     return self;
@@ -243,19 +304,42 @@ buffer_free(VALUE self)
 static void
 buffer_mark(Buffer* ptr)
 {
-    rb_gc_mark(ptr->rbParent);
+    rb_gc_mark(ptr->data.rbParent);
 }
 
 void
 rbffi_Buffer_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-class: FFI::Buffer < FFI::AbstractMemory
+     *
+     * A Buffer is a function argument type. It should be use with functions playing with C arrays.
+     */
     BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
 
+    /*
+     * Document-variable: FFI::Buffer
+     */
     rb_global_variable(&BufferClass);
     rb_define_alloc_func(BufferClass, buffer_allocate);
 
+    /*
+     * Document-method: alloc_inout
+     * call-seq: alloc_inout(*args)
+     * Create a new Buffer for in and out arguments (alias : <i>new_inout</i>).
+     */
     rb_define_singleton_method(BufferClass, "alloc_inout", buffer_alloc_inout, -1);
+    /*
+     * Document-method: alloc_out
+     * call-seq: alloc_out(*args)
+     * Create a new Buffer for out arguments (alias : <i>new_out</i>).
+     */
     rb_define_singleton_method(BufferClass, "alloc_out", buffer_alloc_inout, -1);
+    /*
+     * Document-method: alloc_in
+     * call-seq: alloc_in(*args)
+     * Create a new Buffer for in arguments (alias : <i>new_in</i>).
+     */
     rb_define_singleton_method(BufferClass, "alloc_in", buffer_alloc_inout, -1);
     rb_define_alias(rb_singleton_class(BufferClass), "new_in", "alloc_in");
     rb_define_alias(rb_singleton_class(BufferClass), "new_out", "alloc_out");

data/ext/ffi_c/Call.c

@@ -20,11 +20,19 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
 #include <stdio.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <errno.h>
 #include <ruby.h>
 #if defined(HAVE_NATIVETHREAD) && defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(_WIN32)
@@ -288,7 +296,7 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     void** ffiValues;
     FFIStorage* params;
     VALUE rbReturnValue;
-
+    
 #if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
     rbffi_thread_t oldThread;
 #endif
@@ -329,7 +337,6 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
         oldThread = rbffi_active_thread;
         rbffi_active_thread = rbffi_thread_self();
 #endif
-        retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
         ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
 
 #if !defined(HAVE_RUBY_THREAD_HAS_GVL_P)
@@ -339,9 +346,12 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
 
     if (unlikely(!fnInfo->ignoreErrno)) {
         rbffi_save_errno();
-    }
-
-    return rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
+    }    
+    
+    RB_GC_GUARD(rbReturnValue) = rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
+    RB_GC_GUARD(fnInfo->rbReturnType);
+    
+    return rbReturnValue;
 }
 
 static inline void*
@@ -423,6 +433,7 @@ callback_param(VALUE proc, VALUE cbInfo)
 
     //callback = rbffi_NativeCallback_ForProc(proc, cbInfo);
     callback = rbffi_Function_ForProc(cbInfo, proc);
+    RB_GC_GUARD(callback);
 
     return ((AbstractMemory *) DATA_PTR(callback))->address;
 }

data/ext/ffi_c/ClosurePool.c

@@ -17,22 +17,35 @@
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifndef _MSC_VER
 #include <sys/param.h>
+#endif
 #include <sys/types.h>
 #ifndef _WIN32
 #  include <sys/mman.h>
 #endif
 #include <stdio.h>
+#ifndef _MSC_VER
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #ifndef _WIN32
 #  include <unistd.h>
 #else
+#  include <winsock2.h>
+#  define _WINSOCKAPI_
 #  include <windows.h>
 #endif
 #include <errno.h>
 #include <ruby.h>
 
+#if defined(_MSC_VER) && !defined(INT8_MIN)
+#  include "win32/stdint.h"
+#endif
 #include <ffi.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -68,7 +81,7 @@ struct ClosurePool_ {
     long refcnt;
 };
 
-static int pageSize;
+static long pageSize;
 
 static void* allocatePage(void);
 static bool freePage(void *);
@@ -102,15 +115,14 @@ cleanup_closure_pool(ClosurePool* pool)
         free(memory);
         memory = next;
     }
-    free(pool);
+    xfree(pool);
 }
 
 void
 rbffi_ClosurePool_Free(ClosurePool* pool)
 {
     if (pool != NULL) {
-        int refcnt;
-        refcnt = --(pool->refcnt);
+        long refcnt = --(pool->refcnt);
         if (refcnt == 0) {
             cleanup_closure_pool(pool);
         }
@@ -124,7 +136,8 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     Memory* block = NULL;
     caddr_t code = NULL;
     char errmsg[256];
-    int nclosures, trampolineSize;
+    int nclosures;
+    long trampolineSize;
     int i;
 
     if (pool->list != NULL) {
@@ -136,7 +149,7 @@ rbffi_Closure_Alloc(ClosurePool* pool)
     }
 
     trampolineSize = roundup(pool->closureSize, 8);
-    nclosures = pageSize / trampolineSize;
+    nclosures = (int) (pageSize / trampolineSize);
     block = calloc(1, sizeof(*block));
     list = calloc(nclosures, sizeof(*list));
     code = allocatePage();
@@ -192,7 +205,7 @@ rbffi_Closure_Free(Closure* closure)
 {
     if (closure != NULL) {
         ClosurePool* pool = closure->pool;
-        int refcnt;
+        long refcnt;
         // Just push it on the front of the free list
         closure->next = pool->list;
         pool->list = closure;
@@ -210,7 +223,7 @@ rbffi_Closure_CodeAddress(Closure* handle)
 }
 
 
-static int
+static long
 getPageSize()
 {
 #if defined(_WIN32) || defined(__WIN32__)