ffi 1.9.10-x86-mingw32 → 1.9.11-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fada00c1239d4842bd1180d437f0702b3321465
-  data.tar.gz: d044c7e65502871193ad85dc34415244be1fcd69
+  metadata.gz: 5701daee92930212ce74f3626b08cbb81d00151c
+  data.tar.gz: 7ccaf5ec464f8efd55b32349d6749d4f304e8490
 SHA512:
-  metadata.gz: f1eb6b24237ff38e61a5cb8104fde0eaf403db1ceb97660ce0e6025e7ccd88af539a2ddbe3fb2b21cbe581bc14dcf0026601e6324b3b2844e6a42a727b1597c8
-  data.tar.gz: d5bd3377414c9efd554276bb2fd5cb20c291a7f5a1252dfdfe4c79c4a560bb23b73875a157d66888b2b25cb8360adca1d93a25333909e8e74c764873a175f3cd
+  metadata.gz: 7d09c0b16648f2cfad479b1bf1163333e2bc2ffa066d800749c26941a1f29a12406694fdc30ce1b5d47048f3831537d227fd83a19612d43d86ab55d4cf54ca3c
+  data.tar.gz: 61a818387d862a503e262b20983444b8a7a31bfad2953f01ef4f0aaa66f01ec1564bf10f30c688a7f92e53e7332da09fb252e664c5f853959c334584c38ddc2f

data/Rakefile

@@ -93,13 +93,13 @@ task :package => 'gem:package'
 
 CLOBBER.include 'lib/ffi/types.conf'
 CLOBBER.include 'pkg'
+CLOBBER.include 'log'
 
 CLEAN.include 'build'
 CLEAN.include 'conftest.dSYM'
 CLEAN.include 'spec/ffi/fixtures/libtest.{dylib,so,dll}'
 CLEAN.include 'spec/ffi/fixtures/*.o'
-CLEAN.include "pkg/ffi-#{FFI::VERSION}-*-mingw32"
-CLEAN.include "pkg/ffi-#{FFI::VERSION}-java"
+CLEAN.include "pkg/ffi-*-{mingw32,java}"
 CLEAN.include 'lib/1.*'
 CLEAN.include 'lib/2.*'
 CLEAN.include 'bin'
@@ -138,7 +138,7 @@ end
 task 'spec:run' => TEST_DEPS
 task 'spec:specdoc' => TEST_DEPS
 
-task :default => :specs
+task :default => :spec
 
 namespace 'java' do
 
@@ -175,15 +175,16 @@ if USE_RAKE_COMPILER
     ext.cross_platform = %w[i386-mingw32 x64-mingw32]                     # forces the Windows platform instead of the default one
   end
 
-  ENV['RUBY_CC_VERSION'] ||= '1.8.7:1.9.3:2.0.0:2.1.5:2.2.1'
+  ENV['RUBY_CC_VERSION'] ||= '1.8.7:1.9.3:2.0.0:2.1.6:2.2.2:2.3.0'
 
+  # To reduce the gem file size strip mingw32 dlls before packaging
   ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
-    task "copy:ffi_c:i386-mingw32:#{ruby_version}" do |t|
-      sh "i686-w64-mingw32-strip -S #{BUILD_DIR}/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
+    task "build/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so" do |t|
+      sh "i686-w64-mingw32-strip -S build/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
     end
 
-    task "copy:ffi_c:x64-mingw32:#{ruby_version}" do |t|
-      sh "x86_64-w64-mingw32-strip -S #{BUILD_DIR}/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
+    task "build/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so" do |t|
+      sh "x86_64-w64-mingw32-strip -S build/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
     end
   end
 
@@ -194,6 +195,27 @@ if USE_RAKE_COMPILER
   end
 end
 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'ffi/platform'
+types_conf = File.expand_path(File.join(FFI::Platform::CONF_DIR, 'types.conf'))
+logfile = File.join(File.dirname(__FILE__), 'types_log')
+
+file types_conf => File.join("lib", "ffi", "version.rb") do |task|
+  require 'fileutils'
+  require 'ffi/tools/types_generator'
+  options = {}
+  FileUtils.mkdir_p(File.dirname(task.name), { :mode => 0755 })
+  File.open(task.name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
+    f.puts FFI::TypesGenerator.generate(options)
+  end
+  File.open(logfile, 'w') do |log|
+    log.puts(types_conf)
+  end
+end
+
+task :types_conf => types_conf do
+end
+
 Gem::Tasks.new do |t|
   t.scm.tag.format = '%s'
 end

data/ext/ffi_c/AbstractMemory.c

@@ -497,7 +497,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     off = NUM2LONG(offset);
     idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
     if (idx < 0) {
-        rb_raise(rb_eRangeError, "index canot be less than zero");
+        rb_raise(rb_eRangeError, "index cannot be less than zero");
         return Qnil;
     }
     len = nargs > 3 ? NUM2LONG(rbLength) : (RSTRING_LEN(str) - idx);

data/ext/ffi_c/Buffer.c

@@ -253,7 +253,7 @@ buffer_inspect(VALUE self)
  * @overload order(order)
  *  @param [:big, :little, :network] order
  *  @return [self]
- *  Set endinaness of Buffer (+:network+ is an alias for +:big+).
+ *  Set endianness of Buffer (+:network+ is an alias for +:big+).
  */
 static VALUE
 buffer_order(int argc, VALUE* argv, VALUE self)

data/ext/ffi_c/Call.c

@@ -338,40 +338,27 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
     }
 }
 
-
-typedef struct BlockingCall_ {
-    rbffi_frame_t* frame;
-    void* function;
-    FunctionType* info;
-    void **ffiValues;
-    void* retval;
-    void* params;
-#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
-    void* stkretval;
-#endif
-} BlockingCall;
-
 static VALUE
 call_blocking_function(void* data)
 {
-    BlockingCall* b = (BlockingCall *) data;
+    rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
     b->frame->has_gvl = false;
-    ffi_call(&b->info->ffi_cif, FFI_FN(b->function), b->retval, b->ffiValues);
+    ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
     b->frame->has_gvl = true;
 
     return Qnil;
 }
 
-static VALUE
-do_blocking_call(void *data)
+VALUE
+rbffi_do_blocking_call(void *data)
 {
     rbffi_thread_blocking_region(call_blocking_function, data, (void *) -1, NULL);
 
     return Qnil;
 }
 
-static VALUE
-save_frame_exception(void *data, VALUE exc)
+VALUE
+rbffi_save_frame_exception(void *data, VALUE exc)
 {
     rbffi_frame_t* frame = (rbffi_frame_t *) data;
     frame->exc = exc;
@@ -390,7 +377,7 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
     retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
     
     if (unlikely(fnInfo->blocking)) {
-        BlockingCall* bc;
+        rbffi_blocking_call_t* bc;
 
         /*
          * due to the way thread switching works on older ruby variants, we
@@ -399,16 +386,16 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
         ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
         params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
-        bc = ALLOCA_N(BlockingCall, 1);
+        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
         bc->retval = retval;
 #else
         ffiValues = ALLOC_N(void *, fnInfo->parameterCount);
         params = ALLOC_N(FFIStorage, fnInfo->parameterCount);
-        bc = ALLOC_N(BlockingCall, 1);
+        bc = ALLOC_N(rbffi_blocking_call_t, 1);
         bc->retval = xmalloc(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
         bc->stkretval = retval;
 #endif
-        bc->info = fnInfo;
+        bc->cif = fnInfo->ffi_cif;
         bc->function = function;
         bc->ffiValues = ffiValues;
         bc->params = params;
@@ -419,11 +406,11 @@ rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
             fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
 
         rbffi_frame_push(&frame); 
-        rb_rescue2(do_blocking_call, (VALUE) bc, save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
         rbffi_frame_pop(&frame);
 
 #if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
-        memcpy(bc->stkretval, bc->retval, MAX(bc->info->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
+        memcpy(bc->stkretval, bc->retval, MAX(bc->cif.rtype->size, FFI_SIZEOF_ARG));
         xfree(bc->params);
         xfree(bc->ffiValues);
         xfree(bc->retval);

data/ext/ffi_c/Call.h

@@ -33,6 +33,8 @@
 #ifndef RBFFI_CALL_H
 #define	RBFFI_CALL_H
 
+#include "Thread.h"
+
 #ifdef	__cplusplus
 extern "C" {
 #endif
@@ -85,6 +87,21 @@ Invoker rbffi_GetInvoker(struct FunctionType_* fnInfo);
 extern VALUE rbffi_GetEnumValue(VALUE enums, VALUE value);
 extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxValue, const char* typeName, VALUE enums);
 
+typedef struct rbffi_blocking_call {
+    rbffi_frame_t* frame;
+    void* function;
+    ffi_cif cif;
+    void **ffiValues;
+    void* retval;
+    void* params;
+#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
+    void* stkretval;
+#endif
+} rbffi_blocking_call_t;
+
+VALUE rbffi_do_blocking_call(void* data);
+VALUE rbffi_save_frame_exception(void *data, VALUE exc);
+
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/Function.c

@@ -202,7 +202,7 @@ function_free(Function *fn)
 static VALUE
 function_initialize(int argc, VALUE* argv, VALUE self)
 {
-    
+
     VALUE rbReturnType = Qnil, rbParamTypes = Qnil, rbProc = Qnil, rbOptions = Qnil;
     VALUE rbFunctionInfo = Qnil;
     VALUE infoArgv[3];
@@ -229,14 +229,14 @@ function_initialize(int argc, VALUE* argv, VALUE self)
          *      Function.new(:int, [ :int ], addr, { :convention => :stdcall })
          */
     }
-    
+
     infoArgv[0] = rbReturnType;
     infoArgv[1] = rbParamTypes;
     infoArgv[2] = rbOptions;
     rbFunctionInfo = rb_class_new_instance(rbOptions != Qnil ? 3 : 2, infoArgv, rbffi_FunctionTypeClass);
 
     function_init(self, rbFunctionInfo, rbProc);
-    
+
     return self;
 }
 
@@ -272,12 +272,12 @@ rbffi_Function_ForProc(VALUE rbFunctionInfo, VALUE proc)
             return cbref;
         }
     }
-    
+
     cbTable = RTEST(rb_ivar_defined(proc, id_cbtable)) ? rb_ivar_get(proc, id_cbtable) : Qnil;
     if (cbTable != Qnil && (callback = rb_hash_aref(cbTable, rbFunctionInfo)) != Qnil) {
         return callback;
     }
-    
+
     /* No existing function for the proc with that signature, create a new one and cache it */
     callback = rbffi_Function_NewInstance(rbFunctionInfo, proc);
     if (cbref == Qnil) {
@@ -297,7 +297,7 @@ static VALUE
 function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
 {
     Function* fn = NULL;
-    
+
     Data_Get_Struct(self, Function, fn);
 
     fn->rbFunctionInfo = rbFunctionInfo;
@@ -342,7 +342,7 @@ function_init(VALUE self, VALUE rbFunctionInfo, VALUE rbProc)
         rb_raise(rb_eTypeError, "wrong argument type %s, expected pointer or proc",
                 rb_obj_classname(rbProc));
     }
-    
+
     fn->rbProc = rbProc;
 
     return self;
@@ -402,7 +402,7 @@ function_attach(VALUE self, VALUE module, VALUE name)
     rb_define_singleton_method(module, StringValueCStr(name),
             rbffi_MethodHandle_CodeAddress(fn->methodHandle), -1);
 
-    
+
     rb_define_method(module, StringValueCStr(name),
             rbffi_MethodHandle_CodeAddress(fn->methodHandle), -1);
 
@@ -452,10 +452,10 @@ function_release(VALUE self)
     if (fn->closure == NULL) {
         rb_raise(rb_eRuntimeError, "cannot free function which was not allocated");
     }
-    
+
     rbffi_Closure_Free(fn->closure);
     fn->closure = NULL;
-    
+
     return self;
 }
 
@@ -463,13 +463,13 @@ static void
 callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
 {
     struct gvl_callback cb = { 0 };
-    
+
     cb.closure = (Closure *) user_data;
     cb.retval = retval;
     cb.parameters = parameters;
     cb.done = false;
     cb.frame = rbffi_frame_current();
-    
+
     if (cb.frame != NULL) cb.frame->exc = Qnil;
     if (cb.frame != NULL && cb.frame->has_gvl) {
         callback_with_gvl(&cb);
@@ -651,14 +651,14 @@ async_cb_wait(void *data)
         WaitForSingleObject(async_cb_cond, INFINITE);
         EnterCriticalSection(&async_cb_lock);
     }
-    
+
     if (async_cb_list != NULL) {
         w->cb = async_cb_list;
         async_cb_list = async_cb_list->next;
     }
 
     LeaveCriticalSection(&async_cb_lock);
-    
+
     return Qnil;
 }
 
@@ -686,14 +686,14 @@ async_cb_wait(void *data)
     while (!w->stop && async_cb_list == NULL) {
         pthread_cond_wait(&async_cb_cond, &async_cb_mutex);
     }
-    
+
     if (async_cb_list != NULL) {
         w->cb = async_cb_list;
         async_cb_list = async_cb_list->next;
     }
 
     pthread_mutex_unlock(&async_cb_mutex);
-    
+
     return Qnil;
 }
 
@@ -713,9 +713,9 @@ static VALUE
 async_cb_call(void *data)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
-    
+
     callback_with_gvl(data);
-        
+
     /* Signal the original native thread that the ruby code has completed */
 #ifdef _WIN32
     SetEvent(cb->async_event);
@@ -835,8 +835,7 @@ invoke_callback(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 };
         rbReturnValue = rb_funcall2(((MappedType *) returnType)->rbConverter, id_to_native, 2, values);
@@ -915,7 +914,7 @@ invoke_callback(void* data)
                 } else {
                     memset(retval, 0, returnType->ffiType->size);
                 }
-                
+
             } else {
                 memset(retval, 0, returnType->ffiType->size);
             }
@@ -929,14 +928,14 @@ invoke_callback(void* data)
     return Qnil;
 }
 
-static VALUE 
+static VALUE
 save_callback_exception(void* data, VALUE exc)
 {
     struct gvl_callback* cb = (struct gvl_callback *) data;
-    
+
     memset(cb->retval, 0, ((Function *) cb->closure->info)->info->returnType->ffiType->size);
     if (cb->frame != NULL) cb->frame->exc = exc;
-    
+
     return Qnil;
 }
 
@@ -963,7 +962,7 @@ rbffi_Function_Init(VALUE moduleFFI)
      * Document-class: FFI::Function < FFI::Pointer
      */
     rbffi_FunctionClass = rb_define_class_under(moduleFFI, "Function", rbffi_PointerClass);
-    
+
     rb_global_variable(&rbffi_FunctionClass);
     rb_define_alloc_func(rbffi_FunctionClass, function_allocate);
 
@@ -997,4 +996,3 @@ rbffi_Function_Init(VALUE moduleFFI)
     async_cb_cond = CreateEvent(NULL, FALSE, FALSE, NULL);
 #endif
 }
-

data/ext/ffi_c/MethodHandle.c

@@ -228,9 +228,8 @@ custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
     VALUE rbReturnValue;
-    
+
     RB_GC_GUARD(rbReturnValue) = (*fnInfo->invoke)(argc, argv, handle->function, fnInfo);
-    RB_GC_GUARD_PTR(argv);
     RB_GC_GUARD(self);
 
     return rbReturnValue;
@@ -243,10 +242,10 @@ static VALUE custom_trampoline(caddr_t args, Closure*);
 #define TRAMPOLINE_FUN_MAGIC (0xbeefcafe)
 
 /*
- * This is a hand-coded trampoline to speedup entry from ruby to the FFI translation
+ * This is a hand-coded trampoline to speed-up entry from ruby to the FFI translation
  * layer for i386 arches.
  *
- * This does not make a discernable difference vs a raw closure, so for now,
+ * This does not make a discernible difference vs a raw closure, so for now,
  * it is not enabled.
  */
 __asm__(
@@ -357,4 +356,3 @@ rbffi_MethodHandle_Init(VALUE module)
 
 #endif
 }
-

data/ext/ffi_c/Pointer.c

@@ -89,7 +89,7 @@ ptr_allocate(VALUE klass)
  * @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
+ *  Create a new pointer from a {Type} and a base address
  * @return [self]
  * A new instance of Pointer.
  */
@@ -146,11 +146,11 @@ ptr_initialize(int argc, VALUE* argv, VALUE 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 {RuntimeError} if +other+ is an unbounded memory area, or is unreadable/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+.
+ * This method is internally used by #dup and #clone. Memory content is copied from +other+.
  */
 static VALUE
 ptr_initialize_copy(VALUE self, VALUE other)