ffi 0.5.0 → 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/
@@ -40,10 +31,16 @@ CPU = case Config::CONFIG['host_cpu'].downcase
     else
       "i386"
     end
+
   when /amd64|x86_64/
     "x86_64"
+
+  when /ppc64|powerpc64/
+    "powerpc64"
+
   when /ppc|powerpc/
     "powerpc"
+
   else
     Config::CONFIG['host_cpu']
   end
@@ -78,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.0'
+PROJ.version = '0.6.0'
 PROJ.rubyforge.name = 'ffi'
 PROJ.readme_file = 'README.rdoc'
 
@@ -86,7 +83,7 @@ PROJ.readme_file = 'README.rdoc'
 PROJ.ann.paragraphs << 'FEATURES' << 'SYNOPSIS' << 'REQUIREMENTS' << 'DOWNLOAD/INSTALL' << 'CREDITS' << 'LICENSE'
 
 PROJ.ann.email[:from] = 'andrea.fazzi@alcacoop.it'
-PROJ.ann.email[:to] << 'ruby-ffi@groups.google.com'
+PROJ.ann.email[:to] = ['ruby-ffi@googlegroups.com']
 PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 # Gem specifications

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);
 
@@ -156,6 +157,7 @@ get_pointer_value(VALUE value)
         return MEMORY_PTR(rb_funcall2(value, id_to_ptr, 0, NULL));
     } else {
         rb_raise(rb_eArgError, "value is not a pointer");
+        return NULL;
     }
 }
 
@@ -226,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;
@@ -253,6 +255,7 @@ memory_put_string(VALUE self, VALUE offset, VALUE str)
     
     if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
         rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
+        return Qnil;
     }
 
     memcpy(ptr->address + off, RSTRING_PTR(str), len);
@@ -290,10 +293,12 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     idx = nargs > 2 ? NUM2LONG(rbIndex) : 0;
     if (idx < 0) {
         rb_raise(rb_eRangeError, "index canot be less than zero");
+        return Qnil;
     }
     len = nargs > 3 ? NUM2LONG(rbLength) : (RSTRING_LEN(str) - idx);
     if ((idx + len) > RSTRING_LEN(str)) {
         rb_raise(rb_eRangeError, "index+length is greater than size of string");
+        return Qnil;
     }
 
     checkWrite(ptr);
@@ -301,6 +306,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
 
     if (rb_safe_level() >= 1 && OBJ_TAINTED(str)) {
         rb_raise(rb_eSecurityError, "Writing unsafe string to memory");
+        return Qnil;
     }
     memcpy(ptr->address + off, RSTRING_PTR(str) + idx, len);
 
@@ -395,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,
@@ -428,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); \
@@ -444,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;
@@ -87,6 +86,7 @@ buffer_initialize(int argc, VALUE* argv, VALUE self)
     p->storage = xmalloc(p->memory.size + 7);
     if (p->storage == NULL) {
         rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
+        return Qnil;
     }
 
     /* ensure the memory is aligned on at least a 8 byte boundary */
@@ -110,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;
@@ -131,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)
 {
@@ -152,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;
     }
 
@@ -184,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

@@ -28,14 +28,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _INVOKE_H
-#define	_INVOKE_H
+#ifndef RBFFI_INVOKE_H
+#define	RBFFI_INVOKE_H
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
-#if defined(__i386__) && !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;
@@ -82,5 +86,5 @@ extern int rbffi_GetSignedIntValue(VALUE value, int type, int minValue, int maxV
 }
 #endif
 
-#endif	/* _INVOKE_H */
+#endif	/* RBFFI_INVOKE_H */
 

data/ext/ffi_c/ClosurePool.c

@@ -35,6 +35,8 @@
 #include <stdbool.h>
 #ifndef _WIN32
 #  include <unistd.h>
+#else
+#  include <windows.h>
 #endif
 #include <errno.h>
 #include <ruby.h>
@@ -111,7 +113,7 @@ rbffi_ClosurePool_New(int closureSize,
     pool->prep = prep;
     pool->refcnt = 1;
     
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
+#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32)
     pthread_mutex_init(&pool->mutex, NULL);
 #endif
 
@@ -253,7 +255,7 @@ rbffi_Closure_CodeAddress(Closure* handle)
 static int
 getPageSize()
 {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__WIN32__)
     SYSTEM_INFO si;
     GetSystemInfo(&si);
     return si.dwPageSize;
@@ -265,7 +267,7 @@ getPageSize()
 static void*
 allocatePage(void)
 {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__WIN32__)
     return VirtualAlloc(NULL, pageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 #else
     caddr_t page = mmap(NULL, pageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
@@ -276,7 +278,7 @@ allocatePage(void)
 static bool
 freePage(void *addr)
 {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__WIN32__)
     return VirtualFree(addr, 0, MEM_RELEASE);
 #else
     return munmap(addr, pageSize) == 0;
@@ -286,7 +288,7 @@ freePage(void *addr)
 static bool
 protectPage(void* page)
 {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__WIN32__)
     DWORD oldProtect;
     return VirtualProtect(page, pageSize, PAGE_EXECUTE_READ, &oldProtect);
 #else

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;
@@ -98,6 +97,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     p->storage = xmalloc(msize + 7);
     if (p->storage == NULL) {
         rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", msize);
+        return Qnil;
     }
     p->autorelease = true;
     p->memory.typeSize = size;
@@ -105,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);
     }
@@ -134,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;

data/ext/ffi_c/MethodHandle.c

@@ -175,7 +175,7 @@ attached_method_invoke(ffi_cif* cif, void* mretval, METHOD_PARAMS parameters, vo
     int argc = parameters[0].sint;
     VALUE* argv = *(VALUE **) &parameters[1];
 #else
-    int argc = *(ffi_sarg *) parameters[0];
+    int argc = *(int *) parameters[0];
     VALUE* argv = *(VALUE **) parameters[1];
 #endif