ffi 0.5.4-x86-mingw32 → 0.6.3-x86-mingw32

data/History.txt

@@ -0,0 +1,102 @@
+== 0.5.0 / 2009-10-06
+
+* Major improvements
+  * New Function class
+  * Structs can be passed and returned by value
+  * Implement a custom trampoline for x86_64, resulting in roughly 30% speedup
+  * Improve dispatch of functions which take (0..6) char/short/int/long/pointer arguments by between 50% and 200% on x86_64
+  * Callbacks are now approximately 100% faster on x86_64
+* Minor improvements
+  * Add support for MacOSX Snow Leopard
+  * Improve support for Windows releasing fat binaries on rubyforge
+  * Better introspection in structs:
+    * Add StructLayout::Field#type, size, offset, alignment and name 
+      methods
+    * Add StructLayout#fields which returns an array of 
+      StructLayout::Field objects
+  * Add automagic deducing of library name from module name. 
+    Idea and prototype implementation from Matt Hulse
+  * Callback fields in structs can now be both read and written
+  * Add a bunch of new benchmarks
+  * Lots of refactoring
+* Experimental features
+  * blocking functions (i.e. native code that blocks the thread) support
+* Bug fixes
+  * Fix RUBY-FFI_43 (rake gem dependency)
+
+== 0.4.0 / 2009-08-05
+
+* Major improvements
+  * Add support for boolean types
+  * Add support for methods as callbacks
+  * Add FFI::IO.read as described in JRUBY-3636
+* Minor improvements
+  * Add Pointer::NULL constant
+  * Add AbstractMemory#get_array_of_string()
+  * Implement Pointer.new(address) and Pointer.new(:type, address)
+* Bug fixes
+  * Fix RUBY_FFI-38
+  * Fix issues related to 1.9.1 build
+  * Fix issues related to OSX build
+  * Fix issues related to FreeBSD build
+  * Fix issues related to OpenSolaris build
+
+== 0.3.5 / 2009-05-08
+
+* Bug fixes
+  * Fix RUBY_FFI-17
+  * Fix RUBY_FFI-21
+
+== 0.3.4 / 2009-05-01
+
+* Minor improvements
+  * Add return statements to functions that call rb_raise(), in case
+    rb_raise is not declared noreturn, to avoid gcc warnings.
+
+== 0.3.3 / 2009-04-27
+
+* Minor improvements
+  * Implement RUBY_FFI-16 - Add support for anonymous callbacks
+  * Add support for callback parameters in callbacks
+  * Add support for function pointer return values
+  * Callbacks can now coerce proc objects into function pointers for
+    return values.
+  * Implement FFI::Type and FFI::Type::Builtin
+  * Add support for enumerations
+* Bug fixes
+  * Fix RUBY_FFI-19
+  * Fix RUBY_FFI-15
+
+== 0.3.2 / 2009-05-01
+
+* Bug fixes
+  * Fix JRUBY-3527 by passing RTLD_GLOBAL instead of RTLD_LOCAL
+
+== 0.3.1 / 2009-03-23
+
+* Bug fixes
+  * Correctly save errno/GetLastError after each call.
+
+== 0.3.0 / 2009-03-19
+
+* Switch compilation to rake-compiler
+  * Makes cross-compilation from linux -> win32 super easy
+  * win32 support is available now, but highly experimental
+* Performance improvements
+  * struct field access approx 3x faster than 0.2.0
+  * function invocation approx 20% faster than 0.2.0
+* A bunch of minor improvements
+  * Struct instances can now be passed as :pointer parameters without calling
+    Struct#pointer
+  * Support for array struct members
+  * Structs are now padded correctly to the alignment of the struct's  
+    largest field
+  * Global library variables
+  * Callbacks in global library variables
+  * Strings passed in as :string arguments are scrubbed to avoid 
+    poison-null-byte attacks.
+  * Union support
+  * nil can be passed as a :string argument (passed as NULL)
+  * Structs can now be fields inside another struct
+  * Lots of internal cleanups and refactorings.
+ 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008, JRuby Project
+Copyright (c) 2008, 2009 Ruby FFI contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without 
@@ -23,29 +23,3 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Copyright (c) 2007, Evan Phoenix
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without 
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-* Redistributions in binary form must reproduce the above copyright notice
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-* Neither the name of the Evan Phoenix nor the names of its contributors 
-  may be used to endorse or promote products derived from this software 
-  without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -12,16 +12,7 @@ require 'date'
 require 'fileutils'
 require 'rbconfig'
 
-begin
-  require 'bones'
-  Bones.setup
-rescue LoadError
-  begin
-    load 'tasks/setup.rb'
-  rescue LoadError
-    raise RuntimeError, '### please install the "bones" gem ###'
-  end
-end
+load 'tasks/setup.rb'
 
 LIBEXT = case Config::CONFIG['host_os'].downcase
   when /darwin/
@@ -84,7 +75,7 @@ PROJ.name = 'ffi'
 PROJ.authors = 'Wayne Meissner'
 PROJ.email = 'wmeissner@gmail.com'
 PROJ.url = 'http://wiki.github.com/ffi/ffi'
-PROJ.version = '0.5.4'
+PROJ.version = '0.6.3'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 
@@ -97,7 +88,7 @@ PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 # Gem specifications
 PROJ.gem.need_tar = false
-PROJ.gem.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec}/**/*")
+PROJ.gem.files = %w(History.txt LICENSE README.rdoc Rakefile) + Dir.glob("{ext,gen,lib,spec,tasks}/**/*")
 PROJ.gem.platform = Gem::Platform::RUBY
 
 # Override Mr. Bones autogenerated extensions and force ours in
@@ -156,6 +147,7 @@ task :distclean => :clobber do
   FileUtils.rm_rf(Dir["lib/**/ffi_c.#{Config::CONFIG['DLEXT']}"])
   FileUtils.rm_rf('lib/1.8')
   FileUtils.rm_rf('lib/1.9')
+  FileUtils.rm_rf('lib/ffi/types.conf')
   FileUtils.rm_rf('conftest.dSYM')
   FileUtils.rm_rf('pkg')
 end

data/ext/ffi_c/AbstractMemory.c

@@ -49,7 +49,6 @@ memory_allocate(VALUE klass)
     AbstractMemory* memory;
     VALUE obj;
     obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
-    memory->ops = &rbffi_AbstractMemoryOps;
     memory->access = MEM_RD | MEM_WR;
 
     return obj;
@@ -137,6 +136,8 @@ NUM_OP(int32, int32_t, NUM2INT, INT2NUM);
 NUM_OP(uint32, uint32_t, NUM2UINT, UINT2NUM);
 NUM_OP(int64, int64_t, NUM2LL, LL2NUM);
 NUM_OP(uint64, uint64_t, NUM2ULL, ULL2NUM);
+NUM_OP(long, long, NUM2LONG, LONG2NUM);
+NUM_OP(ulong, unsigned long, NUM2ULONG, ULONG2NUM);
 NUM_OP(float32, float, NUM2DBL, rb_float_new);
 NUM_OP(float64, double, NUM2DBL, rb_float_new);
 
@@ -227,7 +228,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
 
     } else {
         checkBounds(ptr, off, sizeof (char*));
-        for ( ; off < ptr->size - sizeof (void *); off += sizeof (void *)) {
+        for ( ; off < ptr->size - (long) sizeof (void *); off += (long) sizeof (void *)) {
             const char* strptr = *(const char**) (ptr->address + off);
             if (strptr == NULL) {
                 break;
@@ -400,6 +401,8 @@ MemoryOps rbffi_AbstractMemoryOps = {
     .uint32 = &memory_op_uint32,
     .int64 = &memory_op_int64,
     .uint64 = &memory_op_uint64,
+    .slong = &memory_op_long,
+    .ulong = &memory_op_ulong,
     .float32 = &memory_op_float32,
     .float64 = &memory_op_float64,
     .pointer = &memory_op_pointer,
@@ -433,6 +436,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     INT(int16);
     INT(int32);
     INT(int64);
+    INT(long);
     
 #define ALIAS(name, old) \
     rb_define_alias(classMemory, "put_" #name, "put_" #old); \
@@ -449,12 +453,6 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     ALIAS(int, int32);
     ALIAS(long_long, int64);
     
-    if (sizeof(long) == 4) {
-        ALIAS(long, int32);
-    } else {
-        ALIAS(long, int64);
-    }
-
     rb_define_method(classMemory, "put_float32", memory_put_float32, 2);
     rb_define_method(classMemory, "get_float32", memory_get_float32, 1);
     rb_define_alias(classMemory, "put_float", "put_float32");

data/ext/ffi_c/AbstractMemory.h

@@ -61,6 +61,8 @@ typedef struct {
     MemoryOp* uint32;
     MemoryOp* int64;
     MemoryOp* uint64;
+    MemoryOp* slong;
+    MemoryOp* ulong;
     MemoryOp* float32;
     MemoryOp* float64;
     MemoryOp* pointer;
@@ -72,9 +74,12 @@ struct AbstractMemory_ {
     long size;
     int access;
     int typeSize;
-    MemoryOps* ops;
 };
 
+
+extern VALUE rbffi_AbstractMemoryClass;
+extern MemoryOps rbffi_AbstractMemoryOps;
+
 extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
 
 extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
@@ -107,36 +112,37 @@ checkWrite(AbstractMemory* mem)
 }
 
 static inline MemoryOp*
-memory_get_op(AbstractMemory* ptr, Type* type)
+get_memory_op(Type* type)
 {
-    if (ptr == NULL || ptr->ops == NULL || type == NULL) {
-        return NULL;
-    }
     switch (type->nativeType) {
         case NATIVE_INT8:
-            return ptr->ops->int8;
+            return rbffi_AbstractMemoryOps.int8;
         case NATIVE_UINT8:
-            return ptr->ops->uint8;
+            return rbffi_AbstractMemoryOps.uint8;
         case NATIVE_INT16:
-            return ptr->ops->int16;
+            return rbffi_AbstractMemoryOps.int16;
         case NATIVE_UINT16:
-            return ptr->ops->uint16;
+            return rbffi_AbstractMemoryOps.uint16;
         case NATIVE_INT32:
-            return ptr->ops->int32;
+            return rbffi_AbstractMemoryOps.int32;
         case NATIVE_UINT32:
-            return ptr->ops->uint32;
+            return rbffi_AbstractMemoryOps.uint32;
         case NATIVE_INT64:
-            return ptr->ops->int64;
+            return rbffi_AbstractMemoryOps.int64;
         case NATIVE_UINT64:
-            return ptr->ops->uint64;
+            return rbffi_AbstractMemoryOps.uint64;
+        case NATIVE_LONG:
+            return rbffi_AbstractMemoryOps.slong;
+        case NATIVE_ULONG:
+            return rbffi_AbstractMemoryOps.ulong;
         case NATIVE_FLOAT32:
-            return ptr->ops->float32;
+            return rbffi_AbstractMemoryOps.float32;
         case NATIVE_FLOAT64:
-            return ptr->ops->float64;
+            return rbffi_AbstractMemoryOps.float64;
         case NATIVE_POINTER:
-            return ptr->ops->pointer;
+            return rbffi_AbstractMemoryOps.pointer;
         case NATIVE_STRING:
-            return ptr->ops->strptr;
+            return rbffi_AbstractMemoryOps.strptr;
         default:
             return NULL;
     }
@@ -148,10 +154,6 @@ memory_get_op(AbstractMemory* ptr, Type* type)
 
 
 
-extern VALUE rbffi_AbstractMemoryClass;
-extern MemoryOps rbffi_AbstractMemoryOps;
-
-
 #ifdef	__cplusplus
 }
 #endif

data/ext/ffi_c/AutoPointer.c

@@ -25,7 +25,6 @@ autoptr_allocate(VALUE klass)
     AutoPointer* p;
     VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
     p->parent = Qnil;
-    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->memory.access = MEM_RD | MEM_WR;
 
     return obj;

data/ext/ffi_c/Buffer.c

@@ -54,7 +54,6 @@ buffer_allocate(VALUE klass)
 
     obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
     buffer->rbParent = Qnil;
-    buffer->memory.ops = &rbffi_AbstractMemoryOps;
     buffer->memory.access = MEM_RD | MEM_WR;
 
     return obj;
@@ -111,20 +110,18 @@ buffer_alloc_inout(int argc, VALUE* argv, VALUE klass)
 }
 
 static VALUE
-buffer_plus(VALUE self, VALUE rbOffset)
+slice(VALUE self, long offset, long len)
 {
     Buffer* ptr;
     Buffer* result;
     VALUE obj = Qnil;
-    long offset = NUM2LONG(rbOffset);
-
+    
     Data_Get_Struct(self, Buffer, ptr);
-    checkBounds(&ptr->memory, offset, 1);
+    checkBounds(&ptr->memory, offset, len);
 
     obj = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, result);
     result->memory.address = ptr->memory.address + offset;
-    result->memory.size = ptr->memory.size - offset;
-    result->memory.ops = ptr->memory.ops;
+    result->memory.size = len;
     result->memory.access = ptr->memory.access;
     result->memory.typeSize = ptr->memory.typeSize;
     result->rbParent = self;
@@ -132,6 +129,23 @@ buffer_plus(VALUE self, VALUE rbOffset)
     return obj;
 }
 
+static VALUE
+buffer_plus(VALUE self, VALUE rbOffset)
+{
+    Buffer* ptr;
+    long offset = NUM2LONG(rbOffset);
+
+    Data_Get_Struct(self, Buffer, ptr);
+
+    return slice(self, offset, ptr->memory.size - offset);
+}
+
+static VALUE
+buffer_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
+{
+    return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
+}
+
 static VALUE
 buffer_inspect(VALUE self)
 {
@@ -153,7 +167,7 @@ buffer_free(VALUE self)
 
     Data_Get_Struct(self, Buffer, ptr);
     if (ptr->storage != NULL) {
-        free(ptr->storage);
+        xfree(ptr->storage);
         ptr->storage = NULL;
     }
 
@@ -185,4 +199,5 @@ rbffi_Buffer_Init(VALUE moduleFFI)
     rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
     rb_define_alias(BufferClass, "length", "total");
     rb_define_method(BufferClass, "+", buffer_plus, 1);
+    rb_define_method(BufferClass, "slice", buffer_slice, 2);
 }

data/ext/ffi_c/Call.c

@@ -60,6 +60,7 @@
 #define INT16_ADJ (4)
 #define INT32_ADJ (4)
 #define INT64_ADJ (8)
+#define LONG_ADJ (sizeof(long))
 #define FLOAT32_ADJ (4)
 #define FLOAT64_ADJ (8)
 #define ADDRESS_ADJ (sizeof(void *))
@@ -141,10 +142,10 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
 
             case NATIVE_BOOL:
                 if (type != T_TRUE && type != T_FALSE) {
-                    rb_raise(rb_eTypeError, "Expected a Boolean parameter");
+                    rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
                 }
-                param->s32 = argv[argidx++] == Qtrue;
-                ADJ(param, INT32);
+                param->s8 = argv[argidx++] == Qtrue;
+                ADJ(param, INT8);
                 break;
 
 
@@ -186,6 +187,17 @@ rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTy
                 ++argidx;
                 break;
 
+            case NATIVE_LONG:
+                *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
+                ADJ(param, LONG);
+                ++argidx;
+                break;
+
+            case NATIVE_ULONG:
+                *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
+                ADJ(param, LONG);
+                ++argidx;
+                break;
 
             case NATIVE_FLOAT32:
                 if (type != T_FLOAT && type != T_FIXNUM) {
@@ -431,6 +443,8 @@ rbffi_GetInvoker(FunctionType *fnInfo)
         case NATIVE_UINT16:
         case NATIVE_INT32:
         case NATIVE_UINT32:
+        case NATIVE_LONG:
+        case NATIVE_ULONG:
 #ifdef __x86_64__
         case NATIVE_INT64:
         case NATIVE_UINT64:
@@ -452,6 +466,8 @@ rbffi_GetInvoker(FunctionType *fnInfo)
             case NATIVE_UINT16:
             case NATIVE_INT32:
             case NATIVE_UINT32:
+            case NATIVE_LONG:
+            case NATIVE_ULONG:
 #ifdef __x86_64__
             case NATIVE_INT64:
             case NATIVE_UINT64:
@@ -536,6 +552,12 @@ rbffi_GetLongValue(int idx, VALUE* argv, FunctionType* fnInfo)
             /* Special handling/checking for unsigned 32 bit integers */
             return getUnsignedInt32(value, type);
 
+        case NATIVE_LONG:
+            return NUM2LONG(value);
+
+        case NATIVE_ULONG:
+            return NUM2ULONG(value);
+
 #ifdef __x86_64__
         case NATIVE_INT64:
             if (type != T_FIXNUM && type != T_BIGNUM) {
@@ -609,6 +631,9 @@ returnL(FunctionType* fnInfo, L* result)
         case NATIVE_INT32:
           return INT2NUM(*(signed int *) result);
 
+        case NATIVE_LONG:
+          return LONG2NUM(*(signed long *) result);
+
         case NATIVE_UINT8:
           return UINT2NUM(*(unsigned char *) result);
 
@@ -618,6 +643,9 @@ returnL(FunctionType* fnInfo, L* result)
         case NATIVE_UINT32:
           return UINT2NUM(*(unsigned int *) result);
 
+        case NATIVE_ULONG:
+          return ULONG2NUM(*(unsigned long *) result);
+
 #ifdef __x86_64__
         case NATIVE_INT64:
             return LL2NUM(*(signed long long *) result);