ffi 1.9.3-x64-mingw32 → 1.9.5-x64-mingw32

data/spec/ffi/LICENSE.SPECS

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2014 Ruby-FFI contributors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/spec/ffi/async_callback_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "async callback" do
   module LibTest

data/spec/ffi/bool_spec.rb

@@ -4,6 +4,8 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
+
 describe "Function with primitive boolean arguments and return values" do
   module LibTest
     extend FFI::Library

data/spec/ffi/buffer_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "Buffer#total" do
   [1,2,3].each do |i|

data/spec/ffi/callback_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "Callback" do
 #  module LibC
@@ -253,6 +254,9 @@ describe "Callback" do
       s2[:f32] = struct[:f32]
       s2[:s32] = struct[:s32]
     end
+    expect(s2[:s8]).to eql 0x12
+    expect(s2[:s32]).to eql 0x1eefbeef
+    expect(s2[:f32]).to be_within(0.0000001).of 1.234567
   end
 
   
@@ -264,7 +268,7 @@ describe "Callback" do
 
   describe "When the callback is considered optional by the underlying library" do
     it "should handle receiving 'nil' in place of the closure" do
-      LibTest.testOptionalCallbackCrV(nil, 13)
+      LibTest.testOptionalCallbackCrV(nil, 13).should be_nil
     end
   end
 
@@ -288,7 +292,7 @@ describe "Callback" do
         callback :cb_return_type_1, [ :short ], :short
         callback :cb_lookup_1, [ :short ], :cb_return_type_1
         attach_function :testReturnsCallback_1, :testReturnsClosure, [ :cb_lookup_1, :short ], :cb_return_type_1
-      end      
+      end.should be_an_instance_of FFI::Function
     end
 
     it "should return a callback" do
@@ -345,7 +349,7 @@ describe "Callback" do
         callback :cb_argument, [ :int ], :int
         callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
         attach_function :testCallbackAsArgument_2, :testArgumentClosure, [ :cb_with_cb_argument, :int ], :int
-      end   
+      end.should be_an_instance_of FFI::Function
     end
     it 'should be able to use the callback argument' do
       module LibTest
@@ -644,7 +648,7 @@ describe "Callback with " do
     magic = LibTest::S8F32S32.new
     LibTest.testCallbackYrV(magic) { |i| v = i }
     v.class.should == magic.class
-    v.pointer == magic.pointer
+    v.pointer.should == magic.pointer
   end
 
   it "struct by reference argument with nil value" do
@@ -664,4 +668,27 @@ describe "Callback with " do
     }.should raise_error(ArgumentError)
   end
 
+  #
+  # Test stdcall convention with function and callback.
+  # This is Windows 32-bit only.
+  #
+  if FFI::Platform::OS =~ /windows|cygwin/ && FFI::Platform::ARCH == 'i386'
+    module LibTestStdcall
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      ffi_convention :stdcall
+
+      callback :cbStdcall, [ :pointer, :long ], :void
+      attach_function :testCallbackStdcall, 'testClosureStdcall', [ :pointer, :cbStdcall, :long ], :bool
+    end
+
+    it "stdcall convention" do
+      v = 0xdeadbeef
+      po = FFI::MemoryPointer.new :long
+      pr = proc{|a,i| v = a,i; i }
+      res = LibTestStdcall.testCallbackStdcall(po, pr, 0x7fffffff)
+      v.should == [po, 0x7fffffff]
+      res.should be_true
+    end
+  end
 end

data/spec/ffi/custom_param_type.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "functions with custom parameter types" do
   before :each do

data/spec/ffi/custom_type_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "functions with custom types" do
   class Custom_enum

data/spec/ffi/dup_spec.rb

@@ -3,8 +3,8 @@
 # For licensing, see LICENSE.SPECS
 #
 
-
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "Pointer#dup" do 
   it "clone should be independent" do

data/spec/ffi/enum_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 module TestEnum0
   extend FFI::Library

data/spec/ffi/errno_spec.rb

@@ -4,6 +4,8 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
+
 describe "FFI.errno" do
   module LibTest
     extend FFI::Library

data/spec/ffi/ffi_spec.rb

@@ -4,6 +4,7 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'ffi'
 
 describe "FFI" do
 

data/spec/ffi/fixtures/Benchmark.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+#include <sys/types.h>
+#include <stdint.h>
+
+void returnVoid() {
+    
+}
+
+void returnVoidI(int arg) {
+    
+}
+int returnInt() {
+    return 0;
+}
+
+int returnIntI(int arg) {
+    return arg;
+}
+
+typedef int8_t s8;
+typedef uint8_t u8;
+typedef int16_t s16;
+typedef uint16_t u16;
+typedef int32_t s32;
+typedef uint32_t u32;
+typedef int64_t s64;
+typedef uint64_t u64;
+typedef float f32;
+typedef double f64;
+typedef void v;
+typedef char* S;
+typedef void* P;
+
+#define B6(R, T1, T2, T3, T4, T5, T6) R bench_##T1##T2##T3##T4##T5##T6##_##R(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) {}
+#define B5(R, T1, T2, T3, T4, T5) R bench_##T1##T2##T3##T4##T5##_##R(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) {}
+#define B4(R, T1, T2, T3, T4) R bench_##T1##T2##T3##T4##_##R(T1 a1, T2 a2, T3 a3, T4 a4) {}
+#define B3(R, T1, T2, T3) R bench_##T1##T2##T3##_##R(T1 a1, T2 a2, T3 a3) {}
+#define B2(R, T1, T2) R bench_##T1##T2##_##R(T1 a1, T2 a2) {}
+#define B1(R, T1) R bench_##T1##_##R(T1 a1) {}
+#define BrV(T) B1(v, T); B2(v, T, T); B3(v, T, T, T); B4(v, T, T, T, T); B5(v, T, T, T, T, T); B6(v, T, T, T, T, T, T);
+BrV(u32);
+BrV(s32);
+BrV(s64);
+BrV(u64);
+BrV(f32);
+BrV(f64);
+BrV(S);
+BrV(P);

data/spec/ffi/fixtures/BoolTest.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner.
+ * Copyright (c) 2009 Aman Gupta.
+ *
+ * All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdbool.h>
+
+bool
+bool_return_true()
+{
+    return true;
+}
+
+bool
+bool_return_false()
+{
+    return false;
+}
+
+bool
+bool_return_val(bool value)
+{
+    return value;
+}
+
+bool
+bool_reverse_val(bool value)
+{
+    return value ? false : true;
+}

data/spec/ffi/fixtures/BufferTest.c

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+
+#define MEMSET(buf, value, size) do { \
+    int i; for (i = 0; i < size; ++i) buf[i] = value; \
+} while(0)
+#define MEMCPY(dst, src, size) do { \
+    int i; for (i = 0; i < size; ++i) dst[i] = src[i]; \
+} while(0)
+
+#define FILL(JTYPE, CTYPE) \
+void fill##JTYPE##Buffer(CTYPE* buf, CTYPE value, int size) { MEMSET(buf, value, size); }
+
+#define COPY(JTYPE, CTYPE) \
+void copy##JTYPE##Buffer(CTYPE* dst, CTYPE* src, int size) { MEMCPY(dst, src, size); }
+
+#define FUNC(JTYPE, CTYPE) \
+    FILL(JTYPE, CTYPE); \
+    COPY(JTYPE, CTYPE)
+            
+FUNC(Byte, char);
+FUNC(Short, short);
+FUNC(Int, int);
+FUNC(Long, long long);
+FUNC(Float, float);
+FUNC(Double, double);
+

data/spec/ffi/fixtures/ClosureTest.c

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdlib.h>
+#include <stdbool.h>
+#ifndef _WIN32
+# include <pthread.h>
+#else
+# include <windows.h>
+# include <process.h>
+#endif
+
+#define R(T, rtype) rtype testClosureVr##T(rtype (*closure)(void)) { \
+    return closure != NULL ? (*closure)() : (rtype) 0; \
+}
+
+#define P(T, ptype) void testClosure##T##rV(void (*closure)(ptype), ptype a1) { \
+    if (closure != NULL) (*closure)(a1); \
+}
+
+void testClosureVrV(void (*closure)(void))
+{
+    (*closure)();
+}
+
+R(Z, bool);
+R(B, char);
+R(S, short);
+R(I, int);
+R(L, long);
+R(J, long long);
+R(LL, long long);
+R(F, float);
+R(D, double);
+R(P, const void*);
+
+
+P(Z, bool);
+P(B, char);
+P(S, short);
+P(I, int);
+P(L, long);
+P(J, long long);
+P(LL, long long);
+P(F, float);
+P(D, double);
+P(P, const void*);
+P(UL, unsigned long);
+
+void testOptionalClosureBrV(void (*closure)(char), char a1)
+{
+    if (closure) {
+        (*closure)(a1);
+    }
+}
+
+
+struct ThreadVrV {
+    void (*closure)(void);
+    int count;
+};
+
+static void *
+threadVrV(void *arg)
+{
+    struct ThreadVrV* t = (struct ThreadVrV *) arg;
+    
+    int i;
+    for (i = 0; i < t->count; i++) {
+        (*t->closure)();
+    }
+    
+    return NULL;
+}
+
+void testThreadedClosureVrV(void (*closure)(void), int n)
+{
+	struct ThreadVrV arg = {closure, n};
+#ifndef _WIN32
+    pthread_t t;
+    pthread_create(&t, NULL, threadVrV, &arg);
+    pthread_join(t, NULL);
+#else
+    HANDLE hThread = (HANDLE) _beginthread((void (*)(void *))threadVrV, 0, &arg);
+    WaitForSingleObject(hThread, INFINITE);	
+#endif
+}
+
+struct s8f32s32 {
+    char s8;
+    float f32;
+    int s32;
+};
+
+// Takes a struct argument
+void testClosureTrV(void (*closure)(struct s8f32s32 s), struct s8f32s32* s)
+{
+    (*closure)(*s);
+}
+
+// Returns a struct value
+struct s8f32s32 testClosureVrT(struct s8f32s32 (*closure)())
+{
+    return (*closure)();
+}
+
+typedef int (*returnTypeClosure_t)(int) ;
+typedef returnTypeClosure_t (*lookupClosure_t)();
+
+int testReturnsClosure(lookupClosure_t lookup, int val)
+{
+    returnTypeClosure_t func = lookup ? (*lookup)() : NULL;
+    return func ? (*func)(val) : 0;
+}
+
+static int multiplyByTwo(int value)
+{
+    return value * 2;
+}
+
+returnTypeClosure_t testReturnsFunctionPointer()
+{
+    return multiplyByTwo;
+}
+
+typedef int (*argumentClosure_t)(int);
+typedef int (*withArgumentClosure_t)(argumentClosure_t, int);
+
+int testArgumentClosure(withArgumentClosure_t closure_with, argumentClosure_t closure_arg, int val)
+{
+    return (*closure_with)(closure_arg, val);
+}
+
+
+//
+// These macros produce functions of the form:
+// testClosureBIrV(void (*closure)(char, int), char a1, int a2) {}
+//
+#define C2_(J1, J2, N1, N2) \
+void testClosure##J1##J2##rV(void (*closure)(N1, N2), N1 a1, N2 a2) \
+{ \
+    if (closure != NULL) (*closure)(a1, a2); \
+}
+
+#define C2(J, N) \
+    C2_(B, J, char, N) \
+    C2_(S, J, short, N) \
+    C2_(I, J, int, N) \
+    C2_(LL, J, long long, N) \
+    C2_(F, J, float, N) \
+    C2_(D, J, double, N) \
+
+
+C2(B, char);
+C2(S, short);
+C2(I, int);
+C2(LL, long long);
+C2(F, float);
+C2(D, double);
+
+#define C3_(J1, J2, J3, N1, N2, N3) \
+void testClosure##J1##J2##J3##rV(void (*closure)(N1, N2, N3), N1 a1, N2 a2, N3 a3) \
+{ \
+    (*closure)(a1, a2, a3); \
+}
+
+
+#define C3(J, N) \
+    C3_(B, J, B, char, N, char) \
+    C3_(S, J, S, short, N, short) \
+    C3_(I, J, I, int, N, int) \
+    C3_(LL, J, LL, long long, N, long long) \
+    C3_(F, J, F, float, N, float) \
+    C3_(D, J, D, double, N, double) \
+
+C3(B, char);
+C3(S, short);
+C3(I, int);
+C3(LL, long long);
+C3(F, float);
+C3(D, double);
+C3_(B, S, I, char, short, int);
+C3_(B, S, LL, char, short, long long);
+C3_(LL, S, B, long long, short, char);
+C3_(LL, B, S, long long, char, short);
+
+