ffi 1.9.25 → 1.15.0

data/ext/ffi_c/LongDouble.c

@@ -3,15 +3,15 @@
 #include <stdarg.h>
 #include <float.h>
 
-#if defined (__CYGWIN__) || defined(__INTERIX)
+#if defined (__CYGWIN__) || defined(__INTERIX) || defined(_MSC_VER)
 # define strtold(str, endptr)    ((long double) strtod((str), (endptr)))
 #endif /* defined (__CYGWIN__) */
 
 static VALUE rb_cBigDecimal = Qnil;
 static VALUE bigdecimal_load(VALUE unused);
-static VALUE bigdecimal_failed(VALUE value);
+static VALUE bigdecimal_failed(VALUE value, VALUE exc);
 
-VALUE 
+VALUE
 rbffi_longdouble_new(long double ld)
 {
     if (!RTEST(rb_cBigDecimal)) {
@@ -21,27 +21,29 @@ rbffi_longdouble_new(long double ld)
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject) {
         char buf[128];
-        return rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
+        return rb_funcall(rb_mKernel, rb_intern("BigDecimal"), 1, rb_str_new(buf, sprintf(buf, "%.35Le", ld)));
     }
 
     /* Fall through to handling as a float */
     return rb_float_new(ld);
 }
 
-long double 
+long double
 rbffi_num2longdouble(VALUE value)
 {
     if (TYPE(value) == T_FLOAT) {
         return rb_num2dbl(value);
     }
-    
+
     if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
         rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
     }
 
     if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
         VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
-        return strtold(RSTRING_PTR(s), NULL);
+        long double ret = strtold(RSTRING_PTR(s), NULL);
+        RB_GC_GUARD(s);
+        return ret;
     }
 
     /* Fall through to handling as a float */
@@ -49,15 +51,15 @@ rbffi_num2longdouble(VALUE value)
 }
 
 
-static VALUE 
+static VALUE
 bigdecimal_load(VALUE unused)
 {
     rb_require("bigdecimal");
     return rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 }
 
-static VALUE 
-bigdecimal_failed(VALUE value)
+static VALUE
+bigdecimal_failed(VALUE value, VALUE exc)
 {
     return value;
 }

data/ext/ffi_c/LongDouble.h

@@ -36,10 +36,6 @@
 extern "C" {
 #endif
 
-#ifdef _MSC_VER
-#define strtold strtod
-#endif
-
 extern VALUE rbffi_longdouble_new(long double ld);
 extern long double rbffi_num2longdouble(VALUE value);
 

data/ext/ffi_c/MemoryPointer.c

@@ -28,13 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdbool.h>
-# include <stdint.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdbool.h>
+#include <stdint.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -112,7 +107,7 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     p->memory.typeSize = (int) size;
     p->memory.size = msize;
     /* 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->memory.address = (char *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7ULL);
     p->allocated = true;
 
     if (clear && p->memory.size > 0) {

data/ext/ffi_c/MemoryPointer.h

@@ -31,11 +31,7 @@
 #ifndef RBFFI_MEMORYPOINTER_H
 #define	RBFFI_MEMORYPOINTER_H
 
-#ifndef _MSC_VER
 # include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-#endif
 #include <ruby.h>
 
 #ifdef	__cplusplus

data/ext/ffi_c/MethodHandle.c

@@ -34,13 +34,8 @@
 # include <sys/mman.h>
 #endif
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #ifndef _WIN32
 # include <unistd.h>
 #endif
@@ -68,9 +63,6 @@
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
-#ifdef _WIN32
-  typedef char* caddr_t;
-#endif
 
 #ifdef USE_RAW
 #  define METHOD_CLOSURE ffi_raw_closure
@@ -120,23 +112,19 @@ rbffi_MethodHandle_Free(MethodHandle* handle)
 {
     if (handle != NULL) {
         rbffi_Closure_Free(handle->closure);
+        xfree(handle);
     }
 }
 
-void*
-rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
+rbffi_function_anyargs rbffi_MethodHandle_CodeAddress(MethodHandle* handle)
 {
-    return handle->closure->code;
+    return (rbffi_function_anyargs) handle->closure->code;
 }
 
 #ifndef CUSTOM_TRAMPOLINE
 static void attached_method_invoke(ffi_cif* cif, void* retval, METHOD_PARAMS parameters, void* user_data);
 
-static ffi_type* methodHandleParamTypes[] = {
-    &ffi_type_sint,
-    &ffi_type_pointer,
-    &ffi_type_ulong,
-};
+static ffi_type* methodHandleParamTypes[3];
 
 static ffi_cif mh_cif;
 
@@ -148,10 +136,10 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 #if defined(USE_RAW)
     ffiStatus = ffi_prep_raw_closure(code, &mh_cif, attached_method_invoke, closure);
 #else
-    ffiStatus = ffi_prep_closure(code, &mh_cif, attached_method_invoke, closure);
+    ffiStatus = ffi_prep_closure_loc(closure->pcl, &mh_cif, attached_method_invoke, closure, code);
 #endif
     if (ffiStatus != FFI_OK) {
-        snprintf(errmsg, errmsgsize, "ffi_prep_closure failed.  status=%#x", ffiStatus);
+        snprintf(errmsg, errmsgsize, "ffi_prep_closure_loc failed.  status=%#x", ffiStatus);
         return false;
     }
 
@@ -237,7 +225,7 @@ custom_trampoline(int argc, VALUE* argv, VALUE self, Closure* handle)
 
 #elif defined(__i386__) && 0
 
-static VALUE custom_trampoline(caddr_t args, Closure*);
+static VALUE custom_trampoline(void *args, Closure*);
 #define TRAMPOLINE_CTX_MAGIC (0xfee1dead)
 #define TRAMPOLINE_FUN_MAGIC (0xbeefcafe)
 
@@ -269,7 +257,7 @@ __asm__(
 );
 
 static VALUE
-custom_trampoline(caddr_t args, Closure* handle)
+custom_trampoline(void *args, Closure* handle)
 {
     FunctionType* fnInfo = (FunctionType *) handle->info;
     return (*fnInfo->invoke)(*(int *) args, *(VALUE **) (args + 4), handle->function, fnInfo);
@@ -286,10 +274,10 @@ static long trampoline_ctx_offset, trampoline_func_offset;
 static long
 trampoline_offset(int off, const long value)
 {
-    caddr_t ptr;
-    for (ptr = (caddr_t) &ffi_trampoline + off; ptr < (caddr_t) &ffi_trampoline_end; ++ptr) {
+    char *ptr;
+    for (ptr = (char *) &ffi_trampoline + off; ptr < (char *) &ffi_trampoline_end; ++ptr) {
         if (*(long *) ptr == value) {
-            return ptr - (caddr_t) &ffi_trampoline;
+            return ptr - (char *) &ffi_trampoline;
         }
     }
 
@@ -315,12 +303,10 @@ trampoline_offsets(long* ctxOffset, long* fnOffset)
 static bool
 prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t errmsgsize)
 {
-    caddr_t ptr = (caddr_t) code;
-
-    memcpy(ptr, &ffi_trampoline, trampoline_size());
+    memcpy(code, (void*) &ffi_trampoline, trampoline_size());
     /* Patch the context and function addresses into the stub code */
-    *(intptr_t *)(ptr + trampoline_ctx_offset) = (intptr_t) closure;
-    *(intptr_t *)(ptr + trampoline_func_offset) = (intptr_t) custom_trampoline;
+    *(intptr_t *)((char*)code + trampoline_ctx_offset) = (intptr_t) closure;
+    *(intptr_t *)((char*)code + trampoline_func_offset) = (intptr_t) custom_trampoline;
 
     return true;
 }
@@ -328,7 +314,7 @@ prep_trampoline(void* ctx, void* code, Closure* closure, char* errmsg, size_t er
 static long
 trampoline_size(void)
 {
-    return (caddr_t) &ffi_trampoline_end - (caddr_t) &ffi_trampoline;
+    return (char *) &ffi_trampoline_end - (char *) &ffi_trampoline;
 }
 
 #endif /* CUSTOM_TRAMPOLINE */
@@ -348,6 +334,10 @@ rbffi_MethodHandle_Init(VALUE module)
         rb_raise(rb_eFatal, "Could not locate offsets in trampoline code");
     }
 #else
+    methodHandleParamTypes[0] = &ffi_type_sint;
+    methodHandleParamTypes[1] = &ffi_type_pointer;
+    methodHandleParamTypes[2] = &ffi_type_ulong;
+
     ffiStatus = ffi_prep_cif(&mh_cif, FFI_DEFAULT_ABI, 3, &ffi_type_ulong,
             methodHandleParamTypes);
     if (ffiStatus != FFI_OK) {

data/ext/ffi_c/MethodHandle.h

@@ -37,14 +37,15 @@ extern "C" {
 #include <ruby.h>
 #include "Function.h"
 
-    
+
 typedef struct MethodHandlePool MethodHandlePool;
 typedef struct MethodHandle MethodHandle;
+typedef VALUE (*rbffi_function_anyargs)(int argc, VALUE* argv, VALUE self);
 
 
 MethodHandle* rbffi_MethodHandle_Alloc(FunctionType* fnInfo, void* function);
 void rbffi_MethodHandle_Free(MethodHandle* handle);
-void* rbffi_MethodHandle_CodeAddress(MethodHandle* handle);
+rbffi_function_anyargs rbffi_MethodHandle_CodeAddress(MethodHandle* handle);
 void rbffi_MethodHandle_Init(VALUE module);
 
 #ifdef	__cplusplus

data/ext/ffi_c/Platform.c

@@ -31,13 +31,8 @@
 # include <sys/param.h>
 #endif
 # include <sys/types.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ctype.h>
 #include "rbffi_endian.h"
@@ -49,51 +44,6 @@
 
 static VALUE PlatformModule = Qnil;
 
-/*
- * Determine the cpu type at compile time - useful for MacOSX where the the
- * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
- * on intel.
- */
-#if defined(__x86_64__) || defined(__x86_64) || defined(__amd64) || defined(_M_X64) || defined(_M_AMD64)
-# define CPU "x86_64"
-
-#elif defined(__i386__) || defined(__i386) || defined(_M_IX86)
-# define CPU "i386"
-
-#elif defined(__ppc64__) || defined(__powerpc64__) || defined(_M_PPC)
-# define CPU "ppc64"
-
-#elif defined(__ppc__) || defined(__powerpc__) || defined(__powerpc)
-# define CPU "ppc"
-
-/*
- * Need to check for __sparcv9 first, because __sparc will be defined either way.
- * Note that __sparcv9 seems to only be set for Solaris. On Linux, __sparc will
- * be set, along with __arch64__ if a 64-bit platform.
- */
-#elif defined(__sparcv9__) || defined(__sparcv9)
-# define CPU "sparcv9"
-
-#elif defined(__sparc__) || defined(__sparc)
-# if defined(__arch64__)
-#  define CPU "sparcv9"
-# else
-#  define CPU "sparc"
-# endif
-
-#elif defined(__arm__) || defined(__arm)
-# define CPU "arm"
-
-#elif defined(__mips__) || defined(__mips)
-# define CPU "mips"
-
-#elif defined(__s390__)
-# define CPU "s390"
-
-#else
-# define CPU "unknown"
-#endif
-
 static void
 export_primitive_types(VALUE module)
 {
@@ -109,6 +59,7 @@ export_primitive_types(VALUE module)
     S(LONG, long);
     S(FLOAT, float);
     S(DOUBLE, double);
+    S(LONG_DOUBLE, long double);
     S(ADDRESS, void*);
 #undef S
 }
@@ -120,10 +71,8 @@ rbffi_Platform_Init(VALUE moduleFFI)
     rb_define_const(PlatformModule, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
     rb_define_const(PlatformModule, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
     rb_define_const(PlatformModule, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
-    rb_define_const(PlatformModule, "CPU", rb_str_new2(CPU));
 #if defined(__GNU__) || defined(__GLIBC__)
     rb_define_const(PlatformModule, "GNU_LIBC", rb_str_new2(LIBC_SO));
 #endif
     export_primitive_types(PlatformModule);
 }
-

data/ext/ffi_c/Pointer.c

@@ -27,13 +27,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdint.h"
-# include "win32/stdbool.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ruby.h>
 #include "rbffi.h"
@@ -157,14 +152,14 @@ ptr_initialize_copy(VALUE self, VALUE other)
 {
     AbstractMemory* src;
     Pointer* dst;
-    
+
     Data_Get_Struct(self, Pointer, dst);
     src = POINTER(other);
     if (src->size == LONG_MAX) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unbounded memory area");
         return Qnil;
     }
-    
+
     if ((dst->memory.flags & (MEM_RD | MEM_WR)) != (MEM_RD | MEM_WR)) {
         rb_raise(rb_eRuntimeError, "cannot duplicate unreadable/unwritable memory area");
         return Qnil;
@@ -180,13 +175,13 @@ ptr_initialize_copy(VALUE self, VALUE other)
         rb_raise(rb_eNoMemError, "failed to allocate memory size=%lu bytes", src->size);
         return Qnil;
     }
-    
+
     dst->allocated = true;
     dst->autorelease = true;
-    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7UL);
+    dst->memory.address = (void *) (((uintptr_t) dst->storage + 0x7) & (uintptr_t) ~0x7ULL);
     dst->memory.size = src->size;
     dst->memory.typeSize = src->typeSize;
-    
+
     /* finally, copy the actual memory contents */
     memcpy(dst->memory.address, src->address, src->size);
 
@@ -199,7 +194,7 @@ slice(VALUE self, long offset, long size)
     AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
-    
+
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, offset, size == LONG_MAX ? 1 : size);
 
@@ -214,7 +209,7 @@ slice(VALUE self, long offset, long size)
     return retval;
 }
 
-/* 
+/*
  * Document-method: +
  * call-seq: ptr + offset
  * @param [Numeric] offset
@@ -237,7 +232,7 @@ ptr_plus(VALUE self, VALUE offset)
  * @param [Numeric] offset
  * @param [Numeric] length
  * @return [Pointer]
- * Return a new {Pointer} from an existing one. This pointer points on same contents 
+ * Return a new {Pointer} from an existing one. This pointer points on same contents
  * from +offset+ for a length +length+.
  */
 static VALUE
@@ -256,7 +251,7 @@ ptr_inspect(VALUE self)
 {
     char buf[100];
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (ptr->memory.size != LONG_MAX) {
@@ -295,7 +290,7 @@ static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     if (NIL_P(other)) {
@@ -314,7 +309,7 @@ static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
-    
+
     Data_Get_Struct(self, Pointer, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
@@ -331,9 +326,9 @@ ptr_address(VALUE self)
  * @overload order
  *  @return [:big, :little] endianness of +self+
  * @overload order(order)
- *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+ 
+ *  @param  [Symbol] order endianness to set (+:little+, +:big+ or +:network+). +:big+ and +:network+
  *   are synonymous.
- *  @return [self]
+ *  @return a new pointer with the new order
  */
 static VALUE
 ptr_order(int argc, VALUE* argv, VALUE self)
@@ -358,6 +353,8 @@ ptr_order(int argc, VALUE* argv, VALUE self)
 
             } else if (id == rb_intern("big") || id == rb_intern("network")) {
                 order = BIG_ENDIAN;
+            } else {
+                rb_raise(rb_eArgError, "unknown byte order");
             }
         }
         if (order != BYTE_ORDER) {
@@ -395,7 +392,7 @@ ptr_free(VALUE self)
 
     } else {
         VALUE caller = rb_funcall(rb_funcall(Qnil, rb_intern("caller"), 0), rb_intern("first"), 0);
-        
+
         rb_warn("calling free on non allocated pointer %s from %s", RSTRING_PTR(ptr_inspect(self)), RSTRING_PTR(rb_str_to_str(caller)));
     }
 
@@ -408,7 +405,7 @@ ptr_type_size(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return INT2NUM(ptr->memory.typeSize);
 }
 
@@ -440,7 +437,7 @@ ptr_autorelease_p(VALUE self)
     Pointer* ptr;
 
     Data_Get_Struct(self, Pointer, ptr);
-    
+
     return ptr->autorelease ? Qtrue : Qfalse;
 }
 
@@ -472,9 +469,11 @@ rbffi_Pointer_Init(VALUE moduleFFI)
      * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
      * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
      *
-     * ==Autorelease
-     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
-     * changed with {#autorelease=} method.
+     * == Autorelease
+     * By default a pointer object frees its content when it's garbage collected.
+     * Therefore it's usually not necessary to call {#free} explicit.
+     * This behaviour may be changed with {#autorelease=} method.
+     * If it's set to +false+, the memory isn't freed by the garbage collector, but stays valid until +free()+ is called on C level or when the process terminates.
      */
     rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", ffi_AbstractMemory);
     /*