ffi 0.5.4 → 0.6.0

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.0'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 

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 *))
@@ -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);

data/ext/ffi_c/Call.h

@@ -35,7 +35,9 @@
 extern "C" {
 #endif
 
-#if defined(__i386__) && defined(HAVE_RAW_API) && !defined(_WIN32) && !defined(__WIN32__)
+#if defined(__i386__) && \
+  (defined(HAVE_RAW_API) || defined(USE_INTERNAL_LIBFFI)) && \
+  !defined(_WIN32) && !defined(__WIN32__)
 #  define USE_RAW
 #endif
 
@@ -57,6 +59,8 @@ typedef union {
 #endif
     signed long long i64;
     unsigned long long u64;
+    signed long sl;
+    unsigned long ul;
     void* ptr;
     float f32;
     double f64;

data/ext/ffi_c/DynamicLibrary.c

@@ -157,7 +157,6 @@ symbol_new(VALUE library, void* address, VALUE name)
     sym->memory.size = LONG_MAX;
     sym->memory.typeSize = 1;
     sym->memory.access = MEM_RD | MEM_WR;
-    sym->memory.ops = &rbffi_AbstractMemoryOps;
     sym->library = library;
     sym->name = name;
 

data/ext/ffi_c/Function.c

@@ -81,7 +81,6 @@ function_allocate(VALUE klass)
     obj = Data_Make_Struct(klass, Function, function_mark, function_free, fn);
 
     fn->memory.access = MEM_RD;
-    fn->memory.ops = &rbffi_AbstractMemoryOps;
 
     fn->rbProc = Qnil;
     fn->rbFunctionInfo = Qnil;
@@ -250,7 +249,13 @@ function_attach(VALUE self, VALUE module, VALUE name)
     Data_Get_Struct(self, Function, fn);
 
     if (fn->info->parameterCount == -1) {
-        rb_raise(rb_eRuntimeError, "Cannot attach variadic functions");
+        rb_raise(rb_eRuntimeError, "cannot attach variadic functions");
+        return Qnil;
+    }
+
+    if (!rb_obj_is_kind_of(module, rb_cModule)) {
+        rb_raise(rb_eRuntimeError, "trying to attach function to non-module");
+        return Qnil;
     }
 
     if (fn->methodHandle == NULL) {
@@ -350,6 +355,12 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
             case NATIVE_UINT64:
                 param = ULL2NUM(*(uint64_t *) parameters[i]);
                 break;
+            case NATIVE_LONG:
+                param = LONG2NUM(*(long *) parameters[i]);
+                break;
+            case NATIVE_ULONG:
+                param = ULONG2NUM(*(unsigned long *) parameters[i]);
+                break;
             case NATIVE_FLOAT32:
                 param = rb_float_new(*(float *) parameters[i]);
                 break;
@@ -397,6 +408,12 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
         case NATIVE_UINT64:
             *((uint64_t *) retval) = NUM2ULL(rbReturnValue);
             break;
+        case NATIVE_LONG:
+            *((ffi_sarg *) retval) = NUM2LONG(rbReturnValue);
+            break;
+        case NATIVE_ULONG:
+            *((ffi_arg *) retval) = NUM2ULONG(rbReturnValue);
+            break;
         case NATIVE_FLOAT32:
             *((float *) retval) = (float) NUM2DBL(rbReturnValue);
             break;

data/ext/ffi_c/MemoryPointer.c

@@ -63,7 +63,6 @@ memptr_allocate(VALUE klass)
 {
     MemoryPointer* p;
     VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
-    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->memory.access = MEM_RD | MEM_WR;
 
     return obj;
@@ -106,7 +105,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     /* ensure the memory is aligned on at least a 8 byte boundary */
     p->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);;
     p->allocated = true;
-
+    
     if (clear && p->memory.size > 0) {
         memset(p->memory.address, 0, p->memory.size);
     }
@@ -135,7 +134,7 @@ memptr_free(VALUE self)
 
     if (ptr->allocated) {
         if (ptr->storage != NULL) {
-            free(ptr->storage);
+            xfree(ptr->storage);
             ptr->storage = NULL;
         }
         ptr->allocated = false;