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

data/ext/ffi_c/Pointer.h

@@ -21,7 +21,13 @@
 #ifndef RBFFI_POINTER_H
 #define	RBFFI_POINTER_H
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 
 #ifdef	__cplusplus
 extern "C" {

data/ext/ffi_c/Struct.c

@@ -22,9 +22,15 @@
 #include <sys/types.h>
 
 #include "Function.h"
+#ifndef _MSC_VER
 #include <sys/param.h>
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -47,7 +53,7 @@ typedef struct InlineArray_ {
     MemoryOp *op;
     Type* componentType;
     ArrayType* arrayType;
-    unsigned int length;
+    int length;
 } InlineArray;
 
 
@@ -97,7 +103,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 +360,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 +501,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/StructByReference.c

@@ -25,11 +25,19 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#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>
 

data/ext/ffi_c/StructByValue.c

@@ -18,11 +18,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>
 

data/ext/ffi_c/StructLayout.c

@@ -22,9 +22,15 @@
 #include <sys/types.h>
 
 #include "Function.h"
+#ifndef _MSC_VER
 #include <sys/param.h>
 #include <stdint.h>
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -348,7 +354,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 +380,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

@@ -18,13 +18,21 @@
  * 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 _WIN32
 # include <pthread.h>
 # include <errno.h>
 # include <signal.h>
 #else
+# include <winsock2.h>
+# define _WINSOCKAPI_
 # include <windows.h>
 #endif
 #include <fcntl.h>
@@ -179,6 +187,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 +302,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 */
 

data/ext/ffi_c/Thread.h

@@ -21,7 +21,13 @@
 #ifndef RBFFI_THREAD_H
 #define	RBFFI_THREAD_H
 
+#ifndef _MSC_VER
 #include <stdbool.h>
+#else
+typedef int bool;
+#define true 1
+#define false 0
+#endif
 #include <ruby.h>
 #include "extconf.h"
 

data/ext/ffi_c/Type.c

@@ -16,7 +16,10 @@
  * 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 <ruby.h>
 #include <ffi.h>
@@ -51,6 +54,12 @@ type_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * Document-method: initialize
+ * call-seq: initialize(value)
+ * @param [Fixnum,Type] value
+ * @return [self]
+ */
 static VALUE
 type_initialize(VALUE self, VALUE value)
 {
@@ -72,6 +81,11 @@ type_initialize(VALUE self, VALUE value)
     return self;
 }
 
+/*
+ * call-seq: type.size
+ * @return [Fixnum]
+ * Return type's size, in bytes.
+ */
 static VALUE
 type_size(VALUE self)
 {
@@ -82,6 +96,10 @@ type_size(VALUE self)
     return INT2FIX(type->ffiType->size);
 }
 
+/*
+ * call-seq: type.alignment
+ * @return [Fixnum]
+ */
 static VALUE
 type_alignment(VALUE self)
 {
@@ -92,6 +110,11 @@ type_alignment(VALUE self)
     return INT2FIX(type->ffiType->alignment);
 }
 
+/*
+ * call-seq: type.inspect
+ * @return [String]
+ * Inspect {Type} object.
+ */
 static VALUE
 type_inspect(VALUE self)
 {
@@ -128,6 +151,11 @@ builtin_type_free(BuiltinType *type)
     xfree(type);
 }
 
+/*
+ * call-seq: type.inspect
+ * @return [String]
+ * Inspect {Type::Builtin} object.
+ */
 static VALUE
 builtin_type_inspect(VALUE self)
 {
@@ -145,21 +173,29 @@ int
 rbffi_type_size(VALUE type)
 {
     int t = TYPE(type);
+    
     if (t == T_FIXNUM || t == T_BIGNUM) {
         return NUM2INT(type);
+    
     } else if (t == T_SYMBOL) {
         /*
          * Try looking up directly in the type and size maps
          */
         VALUE nType;
-        if ((nType = rb_hash_aref(typeMap, type)) != Qnil) {
-            VALUE nSize = rb_hash_aref(sizeMap, nType);
-            if (TYPE(nSize) == T_FIXNUM) {
-                return FIX2INT(nSize);
+        if ((nType = rb_hash_lookup(typeMap, type)) != Qnil) {
+            if (rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+                Type* type;
+                Data_Get_Struct(nType, Type, type);
+                return (int) type->ffiType->size;
+            
+            } else if (rb_respond_to(nType, id_size)) {
+                return NUM2INT(rb_funcall2(nType, id_size, 0, NULL));
             }
         }
+
         // Not found - call up to the ruby version to resolve
         return NUM2INT(rb_funcall2(rbffi_FFIModule, id_type_size, 1, &type));
+    
     } else {
         return NUM2INT(rb_funcall2(type, id_size, 0, NULL));
     }
@@ -174,7 +210,7 @@ rbffi_Type_Lookup(VALUE name)
          * Try looking up directly in the type Map
          */
         VALUE nType;
-        if ((nType = rb_hash_aref(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+        if ((nType = rb_hash_lookup(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
             return nType;
         }
     } else if (rb_obj_is_kind_of(name, rbffi_TypeClass)) {
@@ -196,7 +232,9 @@ rbffi_Type_Find(VALUE name)
     VALUE rbType = rbffi_Type_Lookup(name);
 
     if (!RTEST(rbType)) {
-        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(rb_inspect(name)));
+        VALUE s = rb_inspect(name);
+        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(s));
+        RB_GC_GUARD(s);
     }
 
     return rbType;
@@ -206,8 +244,18 @@ void
 rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
-    VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
-
+    /*
+     * Document-class: FFI::Type
+     * This class manages C types.
+     *
+     * It embbed {FFI::Type::Builtin} objects as constants (for names,
+     * see {FFI::NativeType}).
+     */
+    rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
+
+    /*
+     * Document-constant: FFI::TypeDefs
+     */
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
     rb_global_variable(&typeMap);
@@ -216,19 +264,62 @@ rbffi_Type_Init(VALUE moduleFFI)
     id_type_size = rb_intern("type_size");
     id_size = rb_intern("size");
 
-
+    /*
+     * Document-class: FFI::Type::Builtin
+     * Class for Built-in types.
+     */
     classBuiltinType = rb_define_class_under(rbffi_TypeClass, "Builtin", rbffi_TypeClass);
+    /*
+     * Document-module: FFI::NativeType
+     * This module defines constants for native (C) types.
+     *
+     * ==Native type constants
+     * Native types are defined by constants :
+     * * INT8, SCHAR, CHAR
+     * * UINT8, UCHAR
+     * * INT16, SHORT, SSHORT
+     * * UINT16, USHORT
+     * * INT32,, INT, SINT
+     * * UINT32, UINT
+     * * INT64, LONG_LONG, SLONG_LONG
+     * * UINT64, ULONG_LONG
+     * * LONG, SLONG
+     * * ULONG
+     * * FLOAT32, FLOAT
+     * * FLOAT64, DOUBLE
+     * * POINTER
+     * * CALLBACK
+     * * FUNCTION
+     * * CHAR_ARRAY
+     * * BOOL
+     * * STRING (immutable string, nul terminated)
+     * * STRUCT (struct-b-value param or result)
+     * * ARRAY (array type definition)
+     * * MAPPED (custom native type)
+     * For function return type only :
+     * * VOID
+     * For function argument type only :
+     * * BUFFER_IN
+     * * BUFFER_OUT
+     * * VARARGS (function takes a variable number of arguments)
+     *
+     * All these constants are exported to {FFI} module prefixed with "TYPE_". 
+     * They are objets from {FFI::Type::Builtin} class.
+     */
     moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
 
+    /*
+     * Document-global: FFI::Type
+     */
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
     rb_global_variable(&moduleNativeType);
 
-    rb_define_alloc_func(classType, type_allocate);
-    rb_define_method(classType, "initialize", type_initialize, 1);
-    rb_define_method(classType, "size", type_size, 0);
-    rb_define_method(classType, "alignment", type_alignment, 0);
-    rb_define_method(classType, "inspect", type_inspect, 0);
+    rb_define_alloc_func(rbffi_TypeClass, type_allocate);
+    rb_define_method(rbffi_TypeClass, "initialize", type_initialize, 1);
+    rb_define_method(rbffi_TypeClass, "size", type_size, 0);
+    rb_define_method(rbffi_TypeClass, "alignment", type_alignment, 0);
+    rb_define_method(rbffi_TypeClass, "inspect", type_inspect, 0);
 
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
@@ -240,16 +331,19 @@ rbffi_Type_Init(VALUE moduleFFI)
     // Define all the builtin types
     #define T(x, ffiType) do { \
         VALUE t = Qnil; \
-        rb_define_const(classType, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
+        rb_define_const(rbffi_TypeClass, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
         rb_define_const(moduleNativeType, #x, t); \
         rb_define_const(moduleFFI, "TYPE_" #x, t); \
     } while(0)
 
     #define A(old_type, new_type) do { \
-        VALUE t = rb_const_get(classType, rb_intern(#old_type)); \
-        rb_const_set(classType, rb_intern(#new_type), t); \
+        VALUE t = rb_const_get(rbffi_TypeClass, rb_intern(#old_type)); \
+        rb_const_set(rbffi_TypeClass, rb_intern(#new_type), t); \
     } while(0)
 
+    /*
+     * Document-constant: FFI::Type::Builtin::VOID
+     */
     T(VOID, &ffi_type_void);
     T(INT8, &ffi_type_sint8);
     A(INT8, SCHAR);