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

data/ext/ffi_c/DataConverter.c

@@ -11,6 +11,15 @@
 VALUE rbffi_DataConverterClass = Qnil;
 static ID id_native_type_ivar;
 
+/*
+ * Get native type.
+ * @overload native_type(type)
+ *  @param [String, Symbol, Type] type
+ *  @return [Type]
+ *  Get native type from +type+.
+ * @overload native_type
+ *  @raise {NotImplementedError} This method must be overriden.
+ */
 static VALUE
 conv_native_type(int argc, VALUE* argv, VALUE self)
 {
@@ -33,12 +42,26 @@ conv_native_type(int argc, VALUE* argv, VALUE self)
     }
 }
 
+/*
+ * call-seq: to_native(value, ctx)
+ * @param value
+ * @param ctx
+ * @return [value]
+ * Convert to a native type.
+ */
 static VALUE
 conv_to_native(VALUE self, VALUE value, VALUE ctx)
 {
     return value;
 }
 
+/*
+ * call-seq: from_native(value, ctx)
+ * @param value
+ * @param ctx
+ * @return [value]
+ * Convert from a native type.
+ */
 static VALUE
 conv_from_native(VALUE self, VALUE value, VALUE ctx)
 {
@@ -50,6 +73,12 @@ conv_from_native(VALUE self, VALUE value, VALUE ctx)
 void
 rbffi_DataConverter_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-module: FFI::DataConverter
+     * This module is used to extend somes classes and give then a common API.
+     *
+     * Most of methods defined here must be overriden.
+     */
     rbffi_DataConverterClass = rb_define_module_under(moduleFFI, "DataConverter");
 
     rb_define_method(rbffi_DataConverterClass, "native_type", conv_native_type, -1);

data/ext/ffi_c/DynamicLibrary.c

@@ -20,13 +20,20 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#include <stdint.h>
+#ifndef _MSC_VER
+#  include <stdint.h>
+#endif
 #if defined(_WIN32) || defined(__WIN32__)
+# include <winsock2.h>
+# define _WINSOCKAPI_
 # include <windows.h>
 #else
 # include <dlfcn.h>
 #endif
 #include <ruby.h>
+#if defined(_MSC_VER) && !defined(INT8_MIN)
+#  include "win32/stdint.h"
+#endif
 
 #include <ffi.h>
 
@@ -75,12 +82,28 @@ library_allocate(VALUE klass)
     return Data_Make_Struct(klass, Library, NULL, library_free, library);
 }
 
+/*
+ * call-seq: DynamicLibrary.open(libname, libflags)
+ * @param libname (see #initialize)
+ * @param libflags (see #initialize)
+ * @return [FFI::DynamicLibrary]
+ * @raise {LoadError} if +libname+ cannot be opened
+ * Open a library.
+ */
 static VALUE
 library_open(VALUE klass, VALUE libname, VALUE libflags)
 {
     return library_initialize(library_allocate(klass), libname, libflags);
 }
 
+/*
+ * call-seq: initialize(libname, libflags)
+ * @param [String] libname name of library to open
+ * @param [Fixnum] libflags flags for library to open
+ * @return [FFI::DynamicLibrary]
+ * @raise {LoadError} if +libname+ cannot be opened
+ * A new DynamicLibrary instance.
+ */
 static VALUE
 library_initialize(VALUE self, VALUE libname, VALUE libflags)
 {
@@ -117,6 +140,10 @@ library_dlsym(VALUE self, VALUE name)
     return address != NULL ? symbol_new(self, address, name) : Qnil;
 }
 
+/*
+ * call-seq: last_error
+ * @return [String] library's last error string
+ */
 static VALUE
 library_dlerror(VALUE self)
 {
@@ -144,7 +171,7 @@ dl_open(const char* name, int flags)
     if (name == NULL) {
         return GetModuleHandle(NULL);
     } else {
-        return LoadLibraryEx(name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+        return LoadLibraryExA(name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
     }
 }
 
@@ -169,6 +196,12 @@ symbol_allocate(VALUE klass)
 }
 
 
+/*
+ * call-seq: initialize_copy(other)
+ * @param [Object] other
+ * @return [nil]
+ * DO NOT CALL THIS METHOD
+ */
 static VALUE
 symbol_initialize_copy(VALUE self, VALUE other)
 {
@@ -199,6 +232,11 @@ symbol_mark(LibrarySymbol* sym)
     rb_gc_mark(sym->name);
 }
 
+/*
+ * call-seq: inspect
+ * @return [String]
+ * Inspect.
+ */
 static VALUE
 symbol_inspect(VALUE self)
 {
@@ -214,18 +252,49 @@ symbol_inspect(VALUE self)
 void
 rbffi_DynamicLibrary_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-class: FFI::DynamicLibrary
+     */
     LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject);
     rb_global_variable(&LibraryClass);
+    /*
+     * Document-class: FFI::DynamicLibrary::Symbol < FFI::Pointer
+     *
+     * An instance of this class represents a library symbol. It may be a {Pointer pointer} to
+     * a function or to a variable.
+     */
     SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass);
     rb_global_variable(&SymbolClass);
 
+    /*
+     * Document-const: FFI::NativeLibrary
+     * Backward compatibility for FFI::DynamicLibrary
+     */
     rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library
     rb_define_alloc_func(LibraryClass, library_allocate);
     rb_define_singleton_method(LibraryClass, "open", library_open, 2);
     rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0);
     rb_define_method(LibraryClass, "initialize", library_initialize, 2);
+    /*
+     * Document-method: find_symbol
+     * call-seq: find_symbol(name)
+     * @param [String] name library symbol's name
+     * @return [FFI::DynamicLibrary::Symbol] library symbol
+     */
     rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1);
+    /*
+     * Document-method: find_function
+     * call-seq: find_function(name)
+     * @param [String] name library function's name
+     * @return [FFI::DynamicLibrary::Symbol] library function symbol
+     */
     rb_define_method(LibraryClass, "find_function", library_dlsym, 1);
+    /*
+     * Document-method: find_variable
+     * call-seq: find_variable(name)
+     * @param [String] name library variable's name
+     * @return [FFI::DynamicLibrary::Symbol] library variable symbol
+     */
     rb_define_method(LibraryClass, "find_variable", library_dlsym, 1);
     rb_define_method(LibraryClass, "last_error", library_dlerror, 0);
     rb_define_attr(LibraryClass, "name", 1, 0);

data/ext/ffi_c/Function.c

@@ -20,16 +20,26 @@
 
 #include "MethodHandle.h"
 
-
+#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
 #include <ruby.h>
+#if defined(_MSC_VER) && !defined(INT8_MIN)
+#  include "win32/stdint.h"
+#endif
 
 #include <ffi.h>
 #if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
@@ -69,9 +79,7 @@ static void callback_invoke(ffi_cif* cif, void* retval, void** parameters, void*
 static bool callback_prep(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize);
 static void* callback_with_gvl(void* data);
 
-#if !defined(_WIN32) || defined(HAVE_RB_THREAD_BLOCKING_REGION)
-# define DEFER_ASYNC_CALLBACK 1
-#endif
+#define DEFER_ASYNC_CALLBACK 1
 
 
 #if defined(DEFER_ASYNC_CALLBACK)
@@ -117,8 +125,11 @@ static struct gvl_callback* async_cb_list = NULL;
     static int async_cb_pipe[2];
 #  endif
 # else
-static HANDLE async_cb_cond;
-static CRITICAL_SECTION async_cb_lock;
+    static HANDLE async_cb_cond;
+    static CRITICAL_SECTION async_cb_lock;
+#  if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    static int async_cb_pipe[2];
+#  endif
 # endif
 #endif
 
@@ -162,6 +173,20 @@ function_free(Function *fn)
     xfree(fn);
 }
 
+/*
+ * @param [Type, Symbol] return_type return type for the function
+ * @param [Array<Type, Symbol>] param_types array of parameters types
+ * @param [Hash] options see {FFI::FunctionType} for available options
+ * @return [self]
+ * A new Function instance.
+ *
+ * Define a function from a Proc or a block.
+ *
+ * @overload initialize(return_type, param_types, options = {}) { |i| ... }
+ *  @yieldparam i parameters for the function
+ * @overload initialize(return_type, param_types, proc, options = {})
+ *  @param [Proc] proc
+ */
 static VALUE
 function_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -202,6 +227,11 @@ function_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: initialize_copy(other)
+ * @return [nil]
+ * DO NOT CALL THIS METHOD
+ */
 static VALUE
 function_initialize_copy(VALUE self, VALUE other)
 {
@@ -277,7 +307,9 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 
 #if defined(DEFER_ASYNC_CALLBACK)
         if (async_cb_thread == Qnil) {
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && defined(_WIN32)
+            _pipe(async_cb_pipe, 1024, O_BINARY);
+#elif !defined(HAVE_RB_THREAD_BLOCKING_REGION)
             pipe(async_cb_pipe);
             fcntl(async_cb_pipe[0], F_SETFL, fcntl(async_cb_pipe[0], F_GETFL) | O_NONBLOCK);
             fcntl(async_cb_pipe[1], F_SETFL, fcntl(async_cb_pipe[1], F_GETFL) | O_NONBLOCK);
@@ -303,6 +335,12 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
     return self;
 }
 
+/*
+ * call-seq: call(*args)
+ * @param [Array] args function arguments
+ * @return [FFI::Type]
+ * Call the function
+ */
 static VALUE
 function_call(int argc, VALUE* argv, VALUE self)
 {
@@ -313,6 +351,13 @@ function_call(int argc, VALUE* argv, VALUE self)
     return (*fn->info->invoke)(argc, argv, fn->base.memory.address, fn->info);
 }
 
+/*
+ * call-seq: attach(m, name)
+ * @param [Module] m
+ * @param [String] name
+ * @return [self]
+ * Attach a Function to the Module +m+ as +name+.
+ */
 static VALUE
 function_attach(VALUE self, VALUE module, VALUE name)
 {
@@ -351,6 +396,12 @@ function_attach(VALUE self, VALUE module, VALUE name)
     return self;
 }
 
+/*
+ * call-seq: autorelease = autorelease
+ * @param [Boolean] autorelease
+ * @return [self]
+ * Set +autorelease+ attribute (See {Pointer}).
+ */
 static VALUE
 function_set_autorelease(VALUE self, VALUE autorelease)
 {
@@ -373,6 +424,11 @@ function_autorelease_p(VALUE self)
     return fn->autorelease ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq: free
+ * @return [self]
+ * Free memory allocated by Function.
+ */
 static VALUE
 function_release(VALUE self)
 {
@@ -441,16 +497,27 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 
 #elif defined(DEFER_ASYNC_CALLBACK) && defined(_WIN32)
     } else {
+        bool empty = false;
+
         cb.async_event = CreateEvent(NULL, FALSE, FALSE, NULL);
-        
+
         // Now signal the async callback thread
         EnterCriticalSection(&async_cb_lock);
+        empty = async_cb_list == NULL;
         cb.next = async_cb_list;
         async_cb_list = &cb;
         LeaveCriticalSection(&async_cb_lock);
 
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        // Only signal if the list was empty
+        if (empty) {
+            char c;
+            write(async_cb_pipe[1], &c, 1);
+        }
+#else
         SetEvent(async_cb_cond);
-        
+#endif
+
         // Wait for the thread executing the ruby callback to signal it is done
         WaitForSingleObject(cb.async_event, INFINITE);
         CloseHandle(cb.async_event);
@@ -481,10 +548,39 @@ async_cb_event(void* unused)
             rb_thread_create(async_cb_call, w.cb);
         }
     }
-    
+
     return Qnil;
 }
 
+#elif defined(_WIN32)
+static VALUE
+async_cb_event(void* unused)
+{
+    while (true) {
+        struct gvl_callback* cb;
+        char buf[64];
+        fd_set rfds;
+
+        FD_ZERO(&rfds);
+        FD_SET(async_cb_pipe[0], &rfds);
+        rb_thread_select(async_cb_pipe[0] + 1, &rfds, NULL, NULL, NULL);
+        read(async_cb_pipe[0], buf, sizeof(buf));
+
+        EnterCriticalSection(&async_cb_lock);
+        cb = async_cb_list;
+        async_cb_list = NULL;
+        LeaveCriticalSection(&async_cb_lock);
+
+        while (cb != NULL) {
+            struct gvl_callback* next = cb->next;
+            // Start up a new ruby thread to run the ruby callback
+            rb_thread_create(async_cb_call, cb);
+            cb = next;
+        }
+    }
+
+    return Qnil;
+}
 #else
 static VALUE
 async_cb_event(void* unused)
@@ -709,6 +805,7 @@ callback_with_gvl(void* data)
     }
 
     rbReturnValue = rb_funcall2(fn->rbProc, id_call, cbInfo->parameterCount, rbParams);
+    RB_GC_GUARD_PTR(rbParams);
     
     if (unlikely(returnType->nativeType == NATIVE_MAPPED)) {
         VALUE values[] = { rbReturnValue, Qnil };
@@ -822,6 +919,9 @@ void
 rbffi_Function_Init(VALUE moduleFFI)
 {
     rbffi_FunctionInfo_Init(moduleFFI);
+    /*
+     * Document-class: FFI::Function < FFI::Pointer
+     */
     rbffi_FunctionClass = rb_define_class_under(moduleFFI, "Function", rbffi_PointerClass);
     
     rb_global_variable(&rbffi_FunctionClass);
@@ -833,7 +933,18 @@ rbffi_Function_Init(VALUE moduleFFI)
     rb_define_method(rbffi_FunctionClass, "attach", function_attach, 2);
     rb_define_method(rbffi_FunctionClass, "free", function_release, 0);
     rb_define_method(rbffi_FunctionClass, "autorelease=", function_set_autorelease, 1);
+    /*
+     * call-seq: autorelease
+     * @return [Boolean]
+     * Get +autorelease+ attribute.
+     * Synonymous for {#autorelease?}.
+     */
     rb_define_method(rbffi_FunctionClass, "autorelease", function_autorelease_p, 0);
+    /*
+     * call-seq: autorelease?
+     * @return [Boolean] +autorelease+ attribute
+     * Get +autorelease+ attribute.
+     */
     rb_define_method(rbffi_FunctionClass, "autorelease?", function_autorelease_p, 0);
 
     id_call = rb_intern("call");
@@ -841,7 +952,7 @@ rbffi_Function_Init(VALUE moduleFFI)
     id_cb_ref = rb_intern("@__ffi_callback__");
     id_to_native = rb_intern("to_native");
     id_from_native = rb_intern("from_native");
-#if defined(_WIN32) && defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(_WIN32)
     InitializeCriticalSection(&async_cb_lock);
     async_cb_cond = CreateEvent(NULL, FALSE, FALSE, NULL);
 #endif