ffi 1.9.10 → 1.9.11

data/ext/ffi_c/Variadic.c

@@ -64,6 +64,7 @@ typedef struct VariadicInvoker_ {
     ffi_abi abi;
     void* function;
     int paramCount;
+    bool blocking;
 } VariadicInvoker;
 
 
@@ -84,6 +85,7 @@ variadic_allocate(VALUE klass)
     invoker->rbAddress = Qnil;
     invoker->rbEnums = Qnil;
     invoker->rbReturnType = Qnil;
+    invoker->blocking = false;
 
     return obj;
 }
@@ -115,6 +117,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums")));
     invoker->rbAddress = rbFunction;
     invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
+    invoker->blocking = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("blocking"))));
 
 #if defined(X86_WIN32)
     rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL);
@@ -253,7 +256,28 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
         ffiValues, NULL, 0, invoker->rbEnums);
     
     rbffi_frame_push(&frame);
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+    /* In Call.c, blocking: true is supported on older ruby variants
+     * without rb_thread_call_without_gvl by allocating on the heap instead
+     * of the stack. Since this functionality is being added later,
+     * we’re skipping support for old rubies here. */
+    if(unlikely(invoker->blocking)) {
+        rbffi_blocking_call_t* bc;
+        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
+        bc->retval = retval;
+        bc->function = invoker->function;
+        bc->ffiValues = ffiValues;
+        bc->params = params;
+        bc->frame = &frame;
+        bc->cif = cif;
+
+        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
+    } else {
+        ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
+    }
+#else
     ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
+#endif
     rbffi_frame_pop(&frame);
     
     rbffi_save_errno();

data/ext/ffi_c/compat.h

@@ -75,9 +75,4 @@
 #  define RB_GC_GUARD(x) (x)
 #endif
 
-#ifndef RB_GC_GUARD_PTR
-#  define RB_GC_GUARD_PTR(x) (x)
-#endif
-
 #endif /* RBFFI_COMPAT_H */
-

data/ext/ffi_c/libffi/src/mips/ffi.c

@@ -76,6 +76,7 @@ static void ffi_prep_args(char *stack,
   void **p_argv;
   char *argp;
   ffi_type **p_arg;
+  int ecif_test;
 
 #ifdef FFI_MIPS_N32
   /* If more than 8 double words are used, the remainder go
@@ -92,10 +93,11 @@ static void ffi_prep_args(char *stack,
   memset(stack, 0, bytes);
 
 #ifdef FFI_MIPS_N32
-  if ( ecif->cif->rstruct_flag != 0 )
+  ecif_test = ecif->cif->rstruct_flag != 0;
 #else
-  if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT )
+  ecif_test = ecif->cif->rtype->type == FFI_TYPE_STRUCT;
 #endif  
+    if (ecif_test)
     {
       *(ffi_arg *) argp = (ffi_arg) ecif->rvalue;
       argp += sizeof(ffi_arg);

data/ext/ffi_c/rbffi_endian.h

@@ -7,7 +7,7 @@
 
 #include <sys/types.h>
 
-#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__)
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__) || defined(__HAIKU__)
 # include <endian.h>
 # if !defined(LITTLE_ENDIAN) && defined(__LITTLE_ENDIAN)
 #  define LITTLE_ENDIAN __LITTLE_ENDIAN

data/ffi.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.8.7'
   s.add_development_dependency 'rake', '~> 10.1'
   s.add_development_dependency 'rake-compiler', '~> 0.9'
-  s.add_development_dependency 'rake-compiler-dock', '~> 0.4.0'
+  s.add_development_dependency 'rake-compiler-dock', '~> 0.5.2'
   s.add_development_dependency 'rspec', '~> 2.14.1'
   s.add_development_dependency 'rubygems-tasks', "~> 0.2.4"
 end

data/lib/ffi/autopointer.rb

@@ -34,27 +34,29 @@ module FFI
     extend DataConverter
 
     # @overload initialize(pointer, method)
-    #  @param [Pointer] pointer
-    #  @param [Method] method
-    #  @return [self]
-    #  The passed Method will be invoked at GC time.
+    #   @param pointer [Pointer]
+    #   @param method [Method]
+    #   @return [self]
+    #   The passed Method will be invoked at GC time.
     # @overload initialize(pointer, proc)
-    #  @param [Pointer] pointer
-    #  @return [self]
-    #  The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
-    #  @note WARNING: passing a proc _may_ cause your pointer to never be GC'd, unless you're 
-    #   careful to avoid trapping a reference to the pointer in the proc. See the test 
-    #   specs for examples.
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The passed Proc will be invoked at GC time (SEE WARNING BELOW!)
+    #   @note WARNING: passing a proc _may_ cause your pointer to never be
+    #     GC'd, unless you're careful to avoid trapping a reference to the
+    #     pointer in the proc. See the test specs for examples.
     # @overload initialize(pointer) { |p| ... }
-    #  @param [Pointer] pointer
-    #  @yieldparam [Pointer] p +pointer+ passed to the block
-    #  @return [self]
-    #  The passed block will be invoked at GC time.
-    #  @note WARNING: passing a block will cause your pointer to never be GC'd. This is bad.
+    #   @param pointer [Pointer]
+    #   @yieldparam [Pointer] p +pointer+ passed to the block
+    #   @return [self]
+    #   The passed block will be invoked at GC time.
+    #   @note
+    #     WARNING: passing a block will cause your pointer to never be GC'd.
+    #     This is bad.
     # @overload initialize(pointer)
-    #  @param [Pointer] pointer
-    #  @return [self]
-    #  The pointer's release() class method will be invoked at GC time.
+    #   @param pointer [Pointer]
+    #   @return [self]
+    #   The pointer's release() class method will be invoked at GC time.
     #
     # @note The safest, and therefore preferred, calling
     #  idiom is to pass a Method as the second parameter. Example usage:
@@ -79,11 +81,15 @@ module FFI
         || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
 
       @releaser = if proc
-                    raise RuntimeError.new("proc must be callable") unless proc.respond_to?(:call)
+                    if not proc.respond_to?(:call)
+                      raise RuntimeError.new("proc must be callable")
+                    end
                     CallableReleaser.new(ptr, proc)
 
                   else
-                    raise RuntimeError.new("no release method defined") unless self.class.respond_to?(:release)
+                    if not self.class.respond_to?(:release)
+                      raise RuntimeError.new("no release method defined")
+                    end
                     DefaultReleaser.new(ptr, self.class)
                   end
 
@@ -143,16 +149,15 @@ module FFI
       def call(*args)
         release(@ptr) if @autorelease && @ptr
       end
-      
     end
 
-    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined without Proc
-    # or Method. In this case, the pointer to release must be of a class derived from 
-    # AutoPointer with a +#release+ class method.
+    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined
+    # without Proc or Method. In this case, the pointer to release must be of
+    # a class derived from AutoPointer with a {release} class method.
     class DefaultReleaser < Releaser
       # @param [Pointer] ptr
       # @return [nil]
-      # Release +ptr+ by using his #release class method.
+      # Release +ptr+ using the {release} class method of its class.
       def release(ptr)
         @proc.release(ptr)
       end
@@ -161,7 +166,9 @@ module FFI
     # CallableReleaser is a {Releaser} used when an {AutoPointer} is defined with a
     # Proc or a Method.
     class CallableReleaser < Releaser
-      # Release +ptr+ by using Proc or Method defined at +ptr+ {AutoPointer#initialize initialization}.
+      # Release +ptr+ by using Proc or Method defined at +ptr+
+      # {AutoPointer#initialize initialization}.
+      #
       # @param [Pointer] ptr
       # @return [nil]
       def release(ptr)
@@ -175,7 +182,9 @@ module FFI
     # @return [Type::POINTER]
     # @raise {RuntimeError} if class does not implement a +#release+ method
     def self.native_type
-      raise RuntimeError.new("no release method defined for #{self.inspect}") unless self.respond_to?(:release)
+      if not self.respond_to?(:release)
+        raise RuntimeError.new("no release method defined for #{self.inspect}")
+      end
       Type::POINTER
     end
 

data/lib/ffi/enum.rb

@@ -146,7 +146,7 @@ module FFI
     def symbol_map
       @kv_map
     end
-    
+
     alias to_h symbol_map
     alias to_hash symbol_map
 
@@ -168,7 +168,5 @@ module FFI
     def from_native(val, ctx)
       @vk_map[val] || val
     end
-
   end
-
 end

data/lib/ffi/library.rb

@@ -109,6 +109,7 @@ module FFI
 
           libnames.each do |libname|
             begin
+              orig = libname
               lib = FFI::DynamicLibrary.open(libname, lib_flags)
               break if lib
 
@@ -121,10 +122,22 @@ module FFI
                 end
               end
 
+              # TODO better library lookup logic
+              unless libname.start_with?("/")
+                path = ['/usr/lib/','/usr/local/lib/'].find do |pth|
+                  File.exist?(pth + libname)
+                end
+                if path
+                  libname = path + libname
+                  retry
+                end
+              end
+
               if ldscript
                 retry
               else
-                errors[libname] = ex
+                libr = (orig == libname ? orig : "#{orig} #{libname}")
+                errors[libr] = ex
               end
             end
           end

data/lib/ffi/pointer.rb

@@ -33,7 +33,7 @@
 require 'ffi/platform'
 module FFI
   class Pointer
-    
+
     # Pointer size
     SIZE = Platform::ADDRESS_SIZE / 8
 

data/lib/ffi/struct.rb

@@ -341,7 +341,7 @@ module FFI
       # @raise if Ruby 1.8
       # Add hash +spec+ to +builder+.
       def hash_layout(builder, spec)
-        raise "Ruby version not supported" if RUBY_VERSION =~ /1\.8\.*/
+        raise "Ruby version not supported" if RUBY_VERSION =~ /^1\.8\..*/
         spec[0].each do |name, type|
           builder.add name, find_field_type(type), nil
         end

data/lib/ffi/tools/types_generator.rb

@@ -1,7 +1,7 @@
 require 'tempfile'
 
 module FFI
-  
+
   # @private
   class TypesGenerator
 
@@ -65,7 +65,7 @@ module FFI
           typedefs = `#{cmd} #{io.path}`
         end
       end
-      
+
       code = ""
 
       typedefs.each_line do |type|
@@ -73,11 +73,11 @@ module FFI
         next unless type =~ /typedef/
         # Ignore unions or structs
         next if type =~ /union|struct/
-        
+
         # strip off the starting typedef and ending ;
         type.gsub!(/^(.*typedef\s*)/, "")
         type.gsub!(/\s*;\s*$/, "")
-    
+
         parts = type.split(/\s+/)
         def_type   = parts.join(" ")
 
@@ -99,7 +99,7 @@ module FFI
           else
             final_type = parts.pop
           end
-          
+
           def_type = case type
                      when /__QI__/   then "char"
                      when /__HI__/   then "short"
@@ -114,7 +114,7 @@ module FFI
           final_type = parts.pop
           def_type   = parts.join(" ")
         end
-        
+
         if type = TYPE_MAP[def_type]
           code << "rbx.platform.typedef.#{final_type} = #{type}\n"
           TYPE_MAP[final_type] = TYPE_MAP[def_type]
@@ -129,7 +129,6 @@ module FFI
 
       code
     end
-
   end
 end
 

data/lib/ffi/types.rb

@@ -65,7 +65,6 @@ module FFI
 
     elsif name.is_a?(DataConverter)
       (type_map || TypeDefs)[name] = Type::Mapped.new(name)
-    
     else
       raise TypeError, "unable to resolve type '#{name}'"
     end
@@ -149,19 +148,24 @@ module FFI
       :varargs => Type::VARARGS,
   })
 
-  
+  # This will convert a pointer to a Ruby string (just like `:string`), but
+  # also allow to work with the pointer itself. This is useful when you want
+  # a Ruby string already containing a copy of the data, but also the pointer
+  # to the data for you to do something with it, like freeing it, in case the
+  # library handed the memory to off to the caller (Ruby-FFI).
+  #
+  # It's {typedef}'d as +:strptr+.
   class StrPtrConverter
     extend DataConverter
     native_type Type::POINTER
 
     # @param [Pointer] val
-    # @param ctx
+    # @param ctx not used
     # @return [Array(String, Pointer)]
     # Returns a [ String, Pointer ] tuple so the C memory for the string can be freed
     def self.from_native(val, ctx)
       [ val.null? ? nil : val.get_string(0), val ]
     end
-
   end
 
   typedef(StrPtrConverter, :strptr)

data/lib/ffi/version.rb

@@ -1,4 +1,4 @@
 module FFI
-  VERSION = '1.9.10'
+  VERSION = '1.9.11'
 end
 

data/libtest/FunctionTest.c

@@ -6,7 +6,7 @@
 
 #ifdef _WIN32
 #include <windows.h>
-#define sleep(x) Sleep(x)
+#define sleep(x) Sleep((x)*1000)
 #endif
 
 #ifndef _WIN32

data/libtest/VariadicTest.c

@@ -60,3 +60,40 @@ void pack_varargs(s64* buf, const char* fmt, ...)
     va_end(ap);
 }
 
+int pack_varargs2(s64* buf, int retval, const char* fmt, ...)
+{
+    va_list ap;
+    int c;
+    double d;
+    va_start(ap, fmt);
+    while ((c = *fmt++)) {
+        switch (c) {
+            case 'c':
+            case 's':
+            case 'i':
+                *buf++ = va_arg(ap, s32);
+                break;
+            case 'l':
+                *buf++ = va_arg(ap, long);
+                break;
+            case 'j':
+                *buf++ = va_arg(ap, s64);
+                break;
+            case 'f':
+            case 'd':
+                d = va_arg(ap, double);
+                memcpy(buf++, &d, sizeof(d));
+                break;
+            case 'C':
+            case 'S':
+            case 'I':
+                *buf++ = va_arg(ap, u32);
+                break;
+            case 'L':
+                *buf++ = va_arg(ap, unsigned long);
+                break;
+        }
+    }
+    va_end(ap);
+    return retval + 1;
+}

data/spec/ffi/fixtures/ClosureTest.c

@@ -50,6 +50,21 @@ P(D, double);
 P(P, const void*);
 P(UL, unsigned long);
 
+#if defined(_WIN32) && !defined(_WIN64)
+bool __stdcall testClosureStdcall(long *a1, void __stdcall(*closure)(void *, long), long a2) { \
+    void* sp_pre;
+    void* sp_post;
+
+    asm volatile (" movl %%esp,%0" : "=g" (sp_pre));
+    (*closure)(a1, a2);
+    asm volatile (" movl %%esp,%0" : "=g" (sp_post));
+
+    /* %esp before pushing parameters on the stack and after the call returns
+     * should be equal, if both sides respects the stdcall convention */
+    return sp_pre == sp_post;
+}
+#endif
+
 void testOptionalClosureBrV(void (*closure)(char), char a1)
 {
     if (closure) {