ffi 1.9.24 → 1.16.3

data/ext/ffi_c/AbstractMemory.c

@@ -32,12 +32,9 @@
 #include <sys/types.h>
 #ifndef _MSC_VER
 # include <sys/param.h>
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
 #endif
+#include <stdint.h>
+#include <stdbool.h>
 
 #include <limits.h>
 #include <ruby.h>
@@ -58,21 +55,30 @@
 # define RB_OBJ_STRING(obj) StringValueCStr(obj)
 #endif
 
+static size_t memsize(const void *data);
 static inline char* memory_address(VALUE self);
 VALUE rbffi_AbstractMemoryClass = Qnil;
 static VALUE NullPointerErrorClass = Qnil;
 static ID id_to_ptr = 0, id_plus = 0, id_call = 0;
 
-static VALUE
-memory_allocate(VALUE klass)
-{
-    AbstractMemory* memory;
-    VALUE obj;
-    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
-    memory->flags = MEM_RD | MEM_WR;
+const rb_data_type_t rbffi_abstract_memory_data_type = { /* extern */
+    .wrap_struct_name = "FFI::AbstractMemory",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = memsize,
+    },
+    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+    // macro to update VALUE references, as to trigger write barriers.
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
 
-    return obj;
+static size_t
+memsize(const void *data)
+{
+    return sizeof(AbstractMemory);
 }
+
 #define VAL(x, swap) (unlikely(((memory->flags & MEM_SWAP) != 0)) ? swap((x)) : (x))
 
 #define NUM_OP(name, type, toNative, fromNative, swap) \
@@ -90,7 +96,7 @@ static VALUE \
 memory_put_##name(VALUE self, VALUE offset, VALUE value) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     memory_op_put_##name(memory, NUM2LONG(offset), value); \
     return self; \
 } \
@@ -99,7 +105,7 @@ static VALUE \
 memory_write_##name(VALUE self, VALUE value) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     memory_op_put_##name(memory, 0, value); \
     return self; \
 } \
@@ -118,7 +124,7 @@ static VALUE \
 memory_get_##name(VALUE self, VALUE offset) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     return memory_op_get_##name(memory, NUM2LONG(offset)); \
 } \
 static VALUE memory_read_##name(VALUE self); \
@@ -126,7 +132,7 @@ static VALUE \
 memory_read_##name(VALUE self) \
 { \
     AbstractMemory* memory; \
-    Data_Get_Struct(self, AbstractMemory, memory); \
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, memory); \
     return memory_op_get_##name(memory, 0); \
 } \
 static MemoryOp memory_op_##name = { memory_op_get_##name, memory_op_put_##name }; \
@@ -135,14 +141,16 @@ static VALUE memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary); \
 static VALUE \
 memory_put_array_of_##name(VALUE self, VALUE offset, VALUE ary) \
 { \
-    long count = RARRAY_LEN(ary); \
+    long count; \
     long off = NUM2LONG(offset); \
     AbstractMemory* memory = MEMORY(self); \
     long i; \
-    checkWrite(memory); \
+    Check_Type(ary, T_ARRAY); \
+    count = RARRAY_LEN(ary); \
+    if (likely(count > 0)) checkWrite(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; i++) { \
-        type tmp = (type) VAL(toNative(RARRAY_PTR(ary)[i]), swap); \
+        type tmp = (type) VAL(toNative(RARRAY_AREF(ary, i)), swap); \
         memcpy(memory->address + off + (i * sizeof(type)), &tmp, sizeof(tmp)); \
     } \
     return self; \
@@ -162,7 +170,7 @@ memory_get_array_of_##name(VALUE self, VALUE offset, VALUE length) \
     AbstractMemory* memory = MEMORY(self); \
     VALUE retVal = rb_ary_new2(count); \
     long i; \
-    checkRead(memory); \
+    if (likely(count > 0)) checkRead(memory); \
     checkBounds(memory, off, count * sizeof(type)); \
     for (i = 0; i < count; ++i) { \
         type tmp; \
@@ -209,13 +217,13 @@ SWAPU16(uint16_t x)
         ((x >> 40) & 0x000000000000ff00ULL) | \
         ((x >> 56) & 0x00000000000000ffULL))
 
-static inline int32_t 
+static inline int32_t
 SWAPS32(int32_t x)
 {
     return bswap32(x);
 }
 
-static inline uint32_t 
+static inline uint32_t
 SWAPU32(uint32_t x)
 {
     return bswap32(x);
@@ -308,6 +316,7 @@ static VALUE
 memory_clear(VALUE self)
 {
     AbstractMemory* ptr = MEMORY(self);
+    checkWrite(ptr);
     memset(ptr->address, 0, ptr->size);
     return self;
 }
@@ -322,7 +331,7 @@ memory_size(VALUE self)
 {
     AbstractMemory* ptr;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     return LONG2NUM(ptr->size);
 }
@@ -341,14 +350,15 @@ memory_get(VALUE self, VALUE type_name, VALUE offset)
     AbstractMemory* ptr;
     VALUE nType;
     Type *type;
+    MemoryOp *op;
 
     nType = rbffi_Type_Lookup(type_name);
     if(NIL_P(nType)) goto undefined_type;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
-    Data_Get_Struct(nType, Type, type);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
+    TypedData_Get_Struct(nType, Type, &rbffi_type_data_type, type);
 
-    MemoryOp *op = get_memory_op(type);
+    op = get_memory_op(type);
     if(op == NULL) goto undefined_type;
 
     return op->get(ptr, NUM2LONG(offset));
@@ -373,14 +383,15 @@ memory_put(VALUE self, VALUE type_name, VALUE offset, VALUE value)
     AbstractMemory* ptr;
     VALUE nType;
     Type *type;
+    MemoryOp *op;
 
     nType = rbffi_Type_Lookup(type_name);
     if(NIL_P(nType)) goto undefined_type;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
-    Data_Get_Struct(nType, Type, type);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
+    TypedData_Get_Struct(nType, Type, &rbffi_type_data_type, type);
 
-    MemoryOp *op = get_memory_op(type);
+    op = get_memory_op(type);
     if(op == NULL) goto undefined_type;
 
     op->put(ptr, NUM2LONG(offset), value);
@@ -417,7 +428,7 @@ memory_get_string(int argc, VALUE* argv, VALUE self)
     checkBounds(ptr, off, len);
 
     end = memchr(ptr->address + off, 0, len);
-    return rb_tainted_str_new((char *) ptr->address + off,
+    return rb_str_new((char *) ptr->address + off,
             (end != NULL ? end - ptr->address - off : len));
 }
 
@@ -443,17 +454,17 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
     count = (countnum == Qnil ? 0 : NUM2INT(countnum));
     retVal = rb_ary_new2(count);
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
     checkRead(ptr);
 
     if (countnum != Qnil) {
         int i;
 
         checkBounds(ptr, off, count * sizeof (char*));
-        
+
         for (i = 0; i < count; ++i) {
             const char* strptr = *((const char**) (ptr->address + off) + i);
-            rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_tainted_str_new2(strptr)));
+            rb_ary_push(retVal, (strptr == NULL ? Qnil : rb_str_new2(strptr)));
         }
 
     } else {
@@ -463,7 +474,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
             if (strptr == NULL) {
                 break;
             }
-            rb_ary_push(retVal, rb_tainted_str_new2(strptr));
+            rb_ary_push(retVal, rb_str_new2(strptr));
         }
     }
 
@@ -477,7 +488,7 @@ memory_get_array_of_string(int argc, VALUE* argv, VALUE self)
  * @param [Numeric] count number of strings to get. If nil, return all strings
  * @return [Array<String>]
  */
-static VALUE 
+static VALUE
 memory_read_array_of_string(int argc, VALUE* argv, VALUE self)
 {
     VALUE* rargv = ALLOCA_N(VALUE, argc + 1);
@@ -535,14 +546,14 @@ memory_get_bytes(VALUE self, VALUE offset, VALUE length)
 {
     AbstractMemory* ptr = MEMORY(self);
     long off, len;
-    
+
     off = NUM2LONG(offset);
     len = NUM2LONG(length);
 
     checkRead(ptr);
     checkBounds(ptr, off, len);
-    
-    return rb_tainted_str_new((char *) ptr->address + off, len);
+
+    return rb_str_new((char *) ptr->address + off, len);
 }
 
 /*
@@ -583,10 +594,6 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
     checkWrite(ptr);
     checkBounds(ptr, off, len);
 
-    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);
 
     return self;
@@ -599,7 +606,7 @@ memory_put_bytes(int argc, VALUE* argv, VALUE self)
  * equivalent to :
  *  memory.get_bytes(0, length)
  */
-static VALUE 
+static VALUE
 memory_read_bytes(VALUE self, VALUE length)
 {
     return memory_get_bytes(self, INT2FIX(0), length);
@@ -614,7 +621,7 @@ memory_read_bytes(VALUE self, VALUE length)
  * equivalent to :
  *  memory.put_bytes(0, str, index, length)
  */
-static VALUE 
+static VALUE
 memory_write_bytes(int argc, VALUE* argv, VALUE self)
 {
     VALUE* wargv = ALLOCA_N(VALUE, argc + 1);
@@ -638,7 +645,7 @@ memory_type_size(VALUE self)
 {
     AbstractMemory* ptr;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     return INT2NUM(ptr->typeSize);
 }
@@ -647,7 +654,7 @@ memory_type_size(VALUE self)
  * Document-method: []
  * call-seq: memory[idx]
  * @param [Numeric] idx index to access in memory
- * @return 
+ * @return
  * Memory read accessor.
  */
 static VALUE
@@ -656,7 +663,7 @@ memory_aref(VALUE self, VALUE idx)
     AbstractMemory* ptr;
     VALUE rbOffset = Qnil;
 
-    Data_Get_Struct(self, AbstractMemory, ptr);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, ptr);
 
     rbOffset = ULONG2NUM(NUM2ULONG(idx) * ptr->typeSize);
 
@@ -666,7 +673,9 @@ memory_aref(VALUE self, VALUE idx)
 static inline char*
 memory_address(VALUE obj)
 {
-    return ((AbstractMemory *) DATA_PTR(obj))->address;
+    AbstractMemory *mem;
+    TypedData_Get_Struct(obj, AbstractMemory, &rbffi_abstract_memory_data_type, mem);
+    return mem->address;
 }
 
 static VALUE
@@ -674,24 +683,33 @@ memory_copy_from(VALUE self, VALUE rbsrc, VALUE rblen)
 {
     AbstractMemory* dst;
 
-    Data_Get_Struct(self, AbstractMemory, dst);
+    TypedData_Get_Struct(self, AbstractMemory, &rbffi_abstract_memory_data_type, dst);
 
-    memcpy(dst->address, rbffi_AbstractMemory_Cast(rbsrc, rbffi_AbstractMemoryClass)->address, NUM2INT(rblen));
+    memcpy(dst->address, rbffi_AbstractMemory_Cast(rbsrc, &rbffi_abstract_memory_data_type)->address, NUM2INT(rblen));
 
     return self;
 }
 
-AbstractMemory*
-rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass)
+/*
+ * call-seq:
+ *    res.freeze
+ *
+ * Freeze the AbstractMemory object and unset the writable flag.
+ */
+static VALUE
+memory_freeze(VALUE self)
 {
-    if (rb_obj_is_kind_of(obj, klass)) {
-        AbstractMemory* memory;
-        Data_Get_Struct(obj, AbstractMemory, memory);
-        return memory;
-    }
+    AbstractMemory* ptr = MEMORY(self);
+    ptr->flags &= ~MEM_WR;
+    return rb_call_super(0, NULL);
+}
 
-    rb_raise(rb_eArgError, "Invalid Memory object");
-    return NULL;
+AbstractMemory*
+rbffi_AbstractMemory_Cast(VALUE obj, const rb_data_type_t *data_type)
+{
+    AbstractMemory* memory;
+    TypedData_Get_Struct(obj, AbstractMemory, data_type, memory);
+    return memory;
 }
 
 void
@@ -718,7 +736,7 @@ memory_op_get_strptr(AbstractMemory* ptr, long offset)
         memcpy(&tmp, ptr->address + offset, sizeof(tmp));
     }
 
-    return tmp != NULL ? rb_tainted_str_new2(tmp) : Qnil;
+    return tmp != NULL ? rb_str_new2(tmp) : Qnil;
 }
 
 static void
@@ -752,9 +770,9 @@ MemoryOps rbffi_AbstractMemoryOps = {
 void
 rbffi_AbstractMemory_Init(VALUE moduleFFI)
 {
-    /* 
+    /*
      * Document-class: FFI::AbstractMemory
-     * 
+     *
      * {AbstractMemory} is the base class for many memory management classes such as {Buffer}.
      *
      * This class has a lot of methods to work with integers :
@@ -782,11 +800,11 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
      */
     VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject);
     rbffi_AbstractMemoryClass = classMemory;
-    /* 
-     * Document-variable: FFI::AbstractMemory 
+    /*
+     * Document-variable: FFI::AbstractMemory
      */
     rb_global_variable(&rbffi_AbstractMemoryClass);
-    rb_define_alloc_func(classMemory, memory_allocate);
+    rb_undef_alloc_func(classMemory);
 
     NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
     /* Document-variable: NullPointerError */
@@ -811,13 +829,13 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "read_array_of_" #type, memory_read_array_of_##type, 1); \
     rb_define_method(classMemory, "write_array_of_u" #type, memory_write_array_of_u##type, 1); \
     rb_define_method(classMemory, "read_array_of_u" #type, memory_read_array_of_u##type, 1);
-    
+
     INT(int8);
     INT(int16);
     INT(int32);
     INT(int64);
     INT(long);
-    
+
 #define ALIAS(name, old) \
     rb_define_alias(classMemory, "put_" #name, "put_" #old); \
     rb_define_alias(classMemory, "get_" #name, "get_" #old); \
@@ -835,12 +853,12 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_alias(classMemory, "read_array_of_" #name, "read_array_of_" #old); \
     rb_define_alias(classMemory, "write_array_of_u" #name, "write_array_of_u" #old); \
     rb_define_alias(classMemory, "read_array_of_u" #name, "read_array_of_u" #old);
-    
+
     ALIAS(char, int8);
     ALIAS(short, int16);
     ALIAS(int, int32);
     ALIAS(long_long, int64);
-    
+
     /*
      * Document-method: put_float32
      * call-seq: memory.put_float32offset, value)
@@ -1101,6 +1119,7 @@ rbffi_AbstractMemory_Init(VALUE moduleFFI)
     rb_define_method(classMemory, "type_size", memory_type_size, 0);
     rb_define_method(classMemory, "[]", memory_aref, 1);
     rb_define_method(classMemory, "__copy_from__", memory_copy_from, 2);
+    rb_define_method(classMemory, "freeze", memory_freeze, 0 );
 
     id_to_ptr = rb_intern("to_ptr");
     id_call = rb_intern("call");

data/ext/ffi_c/AbstractMemory.h

@@ -86,12 +86,13 @@ struct AbstractMemory_ {
 };
 
 
+extern const rb_data_type_t rbffi_abstract_memory_data_type;
 extern VALUE rbffi_AbstractMemoryClass;
 extern MemoryOps rbffi_AbstractMemoryOps;
 
 extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
 
-extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
+extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, const rb_data_type_t *data_type);
 
 extern void rbffi_AbstractMemory_Error(AbstractMemory *, int op);
 
@@ -161,7 +162,7 @@ get_memory_op(Type* type)
     }
 }
 
-#define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), rbffi_AbstractMemoryClass)
+#define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), &rbffi_abstract_memory_data_type)
 #define MEMORY_PTR(obj) MEMORY((obj))->address
 #define MEMORY_LEN(obj) MEMORY((obj))->size
 

data/ext/ffi_c/ArrayType.c

@@ -29,12 +29,30 @@
 
 #include <ruby.h>
 #include <ffi.h>
+#include "compat.h"
 #include "ArrayType.h"
 
 static VALUE array_type_s_allocate(VALUE klass);
 static VALUE array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength);
-static void array_type_mark(ArrayType *);
-static void array_type_free(ArrayType *);
+static void array_type_mark(void *);
+static void array_type_compact(void *);
+static void array_type_free(void *);
+static size_t array_type_memsize(const void *);
+
+const rb_data_type_t rbffi_array_type_data_type = { /* extern */
+  .wrap_struct_name = "FFI::ArrayType",
+  .function = {
+      .dmark = array_type_mark,
+      .dfree = array_type_free,
+      .dsize = array_type_memsize,
+      ffi_compact_callback( array_type_compact )
+  },
+  .parent = &rbffi_type_data_type,
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
 
 VALUE rbffi_ArrayTypeClass = Qnil;
 
@@ -44,32 +62,50 @@ array_type_s_allocate(VALUE klass)
     ArrayType* array;
     VALUE obj;
 
-    obj = Data_Make_Struct(klass, ArrayType, array_type_mark, array_type_free, array);
+    obj = TypedData_Make_Struct(klass, ArrayType, &rbffi_array_type_data_type, array);
 
     array->base.nativeType = NATIVE_ARRAY;
     array->base.ffiType = xcalloc(1, sizeof(*array->base.ffiType));
     array->base.ffiType->type = FFI_TYPE_STRUCT;
     array->base.ffiType->size = 0;
     array->base.ffiType->alignment = 0;
-    array->rbComponentType = Qnil;
+    RB_OBJ_WRITE(obj, &array->rbComponentType, Qnil);
 
     return obj;
 }
 
 static void
-array_type_mark(ArrayType *array)
+array_type_mark(void *data)
+{
+    ArrayType *array = (ArrayType *)data;
+    rb_gc_mark_movable(array->rbComponentType);
+}
+
+static void
+array_type_compact(void *data)
 {
-    rb_gc_mark(array->rbComponentType);
+    ArrayType *array = (ArrayType *)data;
+    ffi_gc_location(array->rbComponentType);
 }
 
 static void
-array_type_free(ArrayType *array)
+array_type_free(void *data)
 {
+    ArrayType *array = (ArrayType *)data;
     xfree(array->base.ffiType);
     xfree(array->ffiTypes);
     xfree(array);
 }
 
+static size_t
+array_type_memsize(const void *data)
+{
+    const ArrayType *array = (const ArrayType *)data;
+    size_t memsize = sizeof(ArrayType);
+    memsize += array->length * sizeof(*array->ffiTypes);
+    memsize += sizeof(*array->base.ffiType);
+    return memsize;
+}
 
 /*
  * call-seq: initialize(component_type, length)
@@ -84,12 +120,12 @@ array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength)
     ArrayType* array;
     int i;
 
-    Data_Get_Struct(self, ArrayType, array);
+    TypedData_Get_Struct(self, ArrayType, &rbffi_array_type_data_type, array);
 
     array->length = NUM2UINT(rbLength);
-    array->rbComponentType = rbComponentType;
-    Data_Get_Struct(rbComponentType, Type, array->componentType);
-    
+    RB_OBJ_WRITE(self, &array->rbComponentType, rbComponentType);
+    TypedData_Get_Struct(rbComponentType, Type, &rbffi_type_data_type, array->componentType);
+
     array->ffiTypes = xcalloc(array->length + 1, sizeof(*array->ffiTypes));
     array->base.ffiType->elements = array->ffiTypes;
     array->base.ffiType->size = array->componentType->ffiType->size * array->length;
@@ -112,7 +148,7 @@ array_type_length(VALUE self)
 {
     ArrayType* array;
 
-    Data_Get_Struct(self, ArrayType, array);
+    TypedData_Get_Struct(self, ArrayType, &rbffi_array_type_data_type, array);
 
     return UINT2NUM(array->length);
 }
@@ -127,7 +163,7 @@ array_type_element_type(VALUE self)
 {
     ArrayType* array;
 
-    Data_Get_Struct(self, ArrayType, array);
+    TypedData_Get_Struct(self, ArrayType, &rbffi_array_type_data_type, array);
 
     return array->rbComponentType;
 }

data/ext/ffi_c/ArrayType.h

@@ -48,6 +48,7 @@ typedef struct ArrayType_ {
 } ArrayType;
 
 extern void rbffi_ArrayType_Init(VALUE moduleFFI);
+extern const rb_data_type_t rbffi_array_type_data_type;
 extern VALUE rbffi_ArrayTypeClass;