ffi 1.0.9 → 1.0.10

data/ext/ffi_c/DynamicLibrary.c

@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdint.h>
 #if defined(_WIN32) || defined(__WIN32__)
+# define _WINSOCKAPI_
 # include <windows.h>
 #else
 # include <dlfcn.h>
@@ -75,12 +76,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 +134,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 +165,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 +190,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 +226,11 @@ symbol_mark(LibrarySymbol* sym)
     rb_gc_mark(sym->name);
 }
 
+/*
+ * call-seq: inspect
+ * @return [String]
+ * Inspect.
+ */
 static VALUE
 symbol_inspect(VALUE self)
 {
@@ -214,18 +246,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

@@ -69,9 +69,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 +115,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 +163,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 +217,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 +297,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 +325,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 +341,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 +386,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 +414,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 +487,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 +538,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 +795,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 +909,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 +923,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 +942,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

data/ext/ffi_c/FunctionInfo.c

@@ -105,7 +105,7 @@ fntype_initialize(int argc, VALUE* argv, VALUE self)
     Check_Type(rbParamTypes, T_ARRAY);
 
     Data_Get_Struct(self, FunctionType, fnInfo);
-    fnInfo->parameterCount = RARRAY_LEN(rbParamTypes);
+    fnInfo->parameterCount = (int) RARRAY_LEN(rbParamTypes);
     fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes));
     fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *));
     fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes));
@@ -201,10 +201,22 @@ fntype_param_types(VALUE self)
 void
 rbffi_FunctionInfo_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-class: FFI::FunctionType < FFI::Type
+     */
     rbffi_FunctionTypeClass = rb_define_class_under(moduleFFI, "FunctionType", rbffi_TypeClass);
     rb_global_variable(&rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::CallbackInfo = FFI::FunctionType
+     */
     rb_define_const(moduleFFI, "CallbackInfo", rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::FunctionInfo = FFI::FunctionType
+     */
     rb_define_const(moduleFFI, "FunctionInfo", rbffi_FunctionTypeClass);
+    /*
+     * Document-const: FFI::Type::Function = FFI::FunctionType
+     */
     rb_define_const(rbffi_TypeClass, "Function", rbffi_FunctionTypeClass);
 
     rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate);

data/ext/ffi_c/LastError.c

@@ -99,6 +99,11 @@ thread_data_get()
 #endif
 
 
+/*
+ * call-seq: error
+ * @return [Numeric]
+ * Get +errno+ value.
+ */
 static VALUE
 get_last_error(VALUE self)
 {
@@ -106,6 +111,12 @@ get_last_error(VALUE self)
 }
 
 
+/*
+ * call-seq: error(error)
+ * @param [Numeric] error
+ * @return [nil]
+ * Set +errno+ value.
+ */
 static VALUE
 set_last_error(VALUE self, VALUE error)
 {
@@ -138,6 +149,11 @@ rbffi_save_errno(void)
 void
 rbffi_LastError_Init(VALUE moduleFFI)
 {
+    /*
+     * Document-module: FFI::LastError
+     * This module defines a couple of method to set and get +errno+
+     * for current thread.
+     */
     VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
 
     rb_define_module_function(moduleError, "error", get_last_error, 0);

data/ext/ffi_c/MappedType.c

@@ -50,6 +50,12 @@ mapped_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * call-seq: initialize(converter)
+ * @param [#native_type, #to_native, #from_native] converter +converter+ must respond to
+ *  all these methods
+ * @return [self]
+ */
 static VALUE
 mapped_initialize(VALUE self, VALUE rbConverter)
 {
@@ -88,6 +94,11 @@ mapped_mark(MappedType* m)
     rb_gc_mark(m->rbConverter);
 }
 
+/*
+ * call-seq: mapped_type.native_type
+ * @return [Type]
+ * Get native type of mapped type.
+ */
 static VALUE
 mapped_native_type(VALUE self)
 {
@@ -97,6 +108,10 @@ mapped_native_type(VALUE self)
     return m->rbType;
 }
 
+/*
+ * call-seq: mapped_type.to_native(*args)
+ * @param args depends on {FFI::DataConverter} used to initialize +self+
+ */
 static VALUE
 mapped_to_native(int argc, VALUE* argv, VALUE self)
 {
@@ -107,6 +122,10 @@ mapped_to_native(int argc, VALUE* argv, VALUE self)
     return rb_funcall2(m->rbConverter, id_to_native, argc, argv);
 }
 
+/*
+ * call-seq: mapped_type.from_native(*args)
+ * @param args depends on {FFI::DataConverter} used to initialize +self+
+ */
 static VALUE
 mapped_from_native(int argc, VALUE* argv, VALUE self)
 {
@@ -121,6 +140,9 @@ void
 rbffi_MappedType_Init(VALUE moduleFFI)
 {
     
+    /* 
+     * Document-class: FFI::Type::Mapped
+     */
     rbffi_MappedTypeClass = rb_define_class_under(rbffi_TypeClass, "Mapped", rbffi_TypeClass);
     
     rb_global_variable(&rbffi_MappedTypeClass);