ffi 0.5.4 → 0.6.0

data/ext/ffi_c/Pointer.c

@@ -59,7 +59,6 @@ rbffi_Pointer_NewInstance(void* addr)
     obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
-    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->memory.access = (addr == NULL) ? 0 : (MEM_RD | MEM_WR);
     p->memory.typeSize = 1;
     p->parent = Qnil;
@@ -75,7 +74,6 @@ ptr_allocate(VALUE klass)
 
     obj = Data_Make_Struct(klass, Pointer, NULL, -1, p);
     p->parent = Qnil;
-    p->memory.ops = &rbffi_AbstractMemoryOps;
     p->memory.access = MEM_RD | MEM_WR;
 
     return obj;
@@ -132,21 +130,19 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
 
 
 static VALUE
-ptr_plus(VALUE self, VALUE offset)
+slice(VALUE self, long offset, long size)
 {
     AbstractMemory* ptr;
     Pointer* p;
     VALUE retval;
-    long off = NUM2LONG(offset);
-
+    
     Data_Get_Struct(self, AbstractMemory, ptr);
-    checkBounds(ptr, off, 1);
+    checkBounds(ptr, offset, 1);
 
     retval = Data_Make_Struct(rbffi_PointerClass, Pointer, ptr_mark, -1, p);
 
-    p->memory.address = ptr->address + off;
-    p->memory.size = ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off;
-    p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->memory.address = ptr->address + offset;
+    p->memory.size = size;
     p->memory.access = ptr->access;
     p->memory.typeSize = ptr->typeSize;
     p->parent = self;
@@ -154,6 +150,23 @@ ptr_plus(VALUE self, VALUE offset)
     return retval;
 }
 
+static VALUE
+ptr_plus(VALUE self, VALUE offset)
+{
+    AbstractMemory* ptr;
+    long off = NUM2LONG(offset);
+
+    Data_Get_Struct(self, AbstractMemory, ptr);
+
+    return slice(self, off, ptr->size == LONG_MAX ? LONG_MAX : ptr->size - off);
+}
+
+static VALUE
+ptr_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
+{
+    return slice(self, NUM2LONG(rbOffset), NUM2LONG(rbLength));
+}
+
 static VALUE
 ptr_inspect(VALUE self)
 {
@@ -214,6 +227,7 @@ rbffi_Pointer_Init(VALUE moduleFFI)
     rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
     rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
     rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
+    rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2);
     rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
     rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
     rb_define_alias(rbffi_PointerClass, "to_i", "address");

data/ext/ffi_c/Struct.c

@@ -63,6 +63,8 @@ typedef struct InlineArray_ {
     StructField* field;
     MemoryOp *op;
     Type* componentType;
+    ArrayType* arrayType;
+    unsigned int length;
 } InlineArray;
 
 
@@ -77,6 +79,8 @@ VALUE rbffi_StructClass = Qnil;
 static VALUE StructLayoutBuilderClass = Qnil;
 
 VALUE rbffi_StructInlineArrayClass = Qnil;
+VALUE rbffi_StructLayoutCharArrayClass = Qnil;
+
 static ID id_pointer_ivar = 0, id_layout_ivar = 0;
 static ID id_get = 0, id_put = 0, id_to_ptr = 0, id_to_s = 0, id_layout = 0;
 
@@ -132,11 +136,6 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
         s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
     }
 
-    if (s->pointer->ops == NULL) {
-        VALUE name = rb_class_name(CLASS_OF(s->rbPointer));
-        rb_raise(rb_eRuntimeError, "No memory ops set for %s", StringValueCStr(name));
-    }
-
     return self;
 }
 
@@ -171,19 +170,22 @@ struct_aref(VALUE self, VALUE fieldName)
     Struct* s;
     VALUE rbField;
     StructField* f;
-    MemoryOp* op;
-
+    
     Data_Get_Struct(self, Struct, s);
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
 
-    op = memory_get_op(s->pointer, f->type);
-    if (op != NULL) {
-        return (*op->get)(s->pointer, f->offset);
-    }
+    if (f->get != NULL) {
+        return (*f->get)(f, s);
+    
+    } else if (f->memoryOp != NULL) {
+        return (*f->memoryOp->get)(s->pointer, f->offset);
+
+    } else {
     
-    /* call up to the ruby code to fetch the value */
-    return rb_funcall2(rbField, id_get, 1, &s->rbPointer);
+        /* call up to the ruby code to fetch the value */
+        return rb_funcall2(rbField, id_get, 1, &s->rbPointer);
+    }
 }
 
 static VALUE
@@ -192,25 +194,27 @@ struct_aset(VALUE self, VALUE fieldName, VALUE value)
     Struct* s;
     VALUE rbField;
     StructField* f;
-    MemoryOp* op;
-    VALUE argv[2];
+
 
     Data_Get_Struct(self, Struct, s);
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
+    if (f->put != NULL) {
+        (*f->put)(f, s, value);
 
-    op = memory_get_op(s->pointer, f->type);
-    if (op != NULL) {
-        (*op->put)(s->pointer, f->offset, value);
-        return self;
-    }
+    } else if (f->memoryOp != NULL) {
+
+        (*f->memoryOp->put)(s->pointer, f->offset, value);
     
-    /* call up to the ruby code to set the value */
-    argv[0] = s->rbPointer;
-    argv[1] = value;
-    rb_funcall2(rbField, id_put, 2, argv);
+    } else {
+        /* call up to the ruby code to set the value */
+        VALUE argv[2];
+        argv[0] = s->rbPointer;
+        argv[1] = value;
+        rb_funcall2(rbField, id_put, 2, argv);
+    }
     
-    return self;
+    return value;
 }
 
 static VALUE
@@ -425,16 +429,32 @@ struct_layout_builder_add_field(int argc, VALUE* argv, VALUE self)
         fargv[0] = rbName;
         fargv[1] = UINT2NUM(offset);
         fargv[2] = rbType;
+        
         if (rb_obj_is_kind_of(rbType, rbffi_FunctionTypeClass)) {
+
             rbFieldClass = rbffi_StructLayoutFunctionFieldClass;
+
         } else if (rb_obj_is_kind_of(rbType, rbffi_StructByValueClass)) {
-            rbFieldClass = rbffi_StructLayoutStructFieldClass;
+            
+            rbFieldClass = rb_const_get(rbffi_StructLayoutClass, rb_intern("InlineStruct"));
+
         } else if (rb_obj_is_kind_of(rbType, rbffi_ArrayTypeClass)) {
+
             rbFieldClass = rbffi_StructLayoutArrayFieldClass;
+
+        } else if (rb_obj_is_kind_of(rbType, rbffi_EnumTypeClass)) {
+
+            rbFieldClass = rb_const_get(rbffi_StructLayoutClass, rb_intern("Enum"));
+
         } else {
             rbFieldClass = rbffi_StructLayoutFieldClass;
         }
 
+        if (!RTEST(rbFieldClass)) {
+            rb_raise(rb_eTypeError, "invalid struct field type (%s)", rb_obj_classname(rbType));
+            return Qnil;
+        }
+
         rbField = rb_class_new_instance(3, fargv, rbFieldClass);
     } else {
         rbField = rbType;
@@ -449,7 +469,8 @@ static VALUE
 struct_layout_builder_add_struct(int argc, VALUE* argv, VALUE self)
 {
     StructLayoutBuilder* builder;
-    VALUE rbName = Qnil, rbType = Qnil, rbOffset = Qnil, rbField = Qnil, rbStructClass = Qnil;
+    VALUE rbName = Qnil, rbType = Qnil, rbOffset = Qnil, rbField = Qnil;
+    VALUE rbFieldClass = Qnil, rbStructClass = Qnil;
     VALUE fargv[3];
     unsigned int size, alignment, offset;
     int nargs;
@@ -472,7 +493,14 @@ struct_layout_builder_add_struct(int argc, VALUE* argv, VALUE self)
     fargv[0] = rbName;
     fargv[1] = UINT2NUM(offset);
     fargv[2] = rbType;
-    rbField = rb_class_new_instance(3, fargv, rbffi_StructLayoutStructFieldClass);
+    rbFieldClass = rb_const_get(rbffi_StructLayoutClass, rb_intern("InlineStruct"));
+    if (!RTEST(rbFieldClass)) {
+        rb_raise(rb_eRuntimeError, "could not locate StructLayout::InlineStruct");
+        return Qnil;
+    }
+    
+    rbField = rb_class_new_instance(3, fargv, rbFieldClass);
+
     store_field(builder, rbName, rbField, offset, size, alignment);
 
     return self;
@@ -554,21 +582,18 @@ static VALUE
 inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
 {
     InlineArray* array;
-    ArrayType* arrayType;
-
+    
     Data_Get_Struct(self, InlineArray, array);
     array->rbMemory = rbMemory;
     array->rbField = rbField;
 
     Data_Get_Struct(rbMemory, AbstractMemory, array->memory);
     Data_Get_Struct(rbField, StructField, array->field);
-    Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
-    Data_Get_Struct(arrayType->rbComponentType, Type, array->componentType);
+    Data_Get_Struct(array->field->rbType, ArrayType, array->arrayType);
+    Data_Get_Struct(array->arrayType->rbComponentType, Type, array->componentType);
     
-    array->op = memory_get_op(array->memory, array->componentType);
-    if (array->op == NULL) {
-        rb_raise(rb_eRuntimeError, "invalid memory ops");
-    }
+    array->op = get_memory_op(array->componentType);
+    array->length = array->arrayType->length;
 
     return self;
 }
@@ -584,8 +609,12 @@ inline_array_size(VALUE self)
 }
 
 static int
-inline_array_offset(InlineArray* array, unsigned int index)
+inline_array_offset(InlineArray* array, int index)
 {
+    if (index < 0 || index >= array->length) {
+        rb_raise(rb_eIndexError, "index %d out of bounds", index);
+    }
+
     return array->field->offset + (index * array->componentType->ffiType->size);
 }
 
@@ -596,7 +625,19 @@ inline_array_aref(VALUE self, VALUE rbIndex)
 
     Data_Get_Struct(self, InlineArray, array);
 
-    return array->op->get(array->memory, inline_array_offset(array, NUM2UINT(rbIndex)));
+    if (array->op != NULL) {
+        return array->op->get(array->memory, inline_array_offset(array, NUM2INT(rbIndex)));
+    } else if (array->componentType->nativeType == NATIVE_STRUCT) {
+        VALUE rbOffset = INT2NUM(inline_array_offset(array, NUM2INT(rbIndex)));
+        VALUE rbLength = INT2NUM(array->componentType->ffiType->size);
+        VALUE rbPointer = rb_funcall(array->rbMemory, rb_intern("slice"), 2, rbOffset, rbLength);
+
+        return rb_class_new_instance(1, &rbPointer, ((StructByValue *) array->componentType)->rbStructClass);
+    } else {
+
+        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(array->arrayType->rbComponentType));
+        return Qnil;
+    }
 }
 
 static VALUE
@@ -606,8 +647,34 @@ inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
 
     Data_Get_Struct(self, InlineArray, array);
 
-    array->op->put(array->memory, inline_array_offset(array, NUM2UINT(rbIndex)),
-        rbValue);
+    if (array->op != NULL) {
+        array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
+            rbValue);
+    } else if (array->componentType->nativeType == NATIVE_STRUCT) {
+        int offset = inline_array_offset(array, NUM2INT(rbIndex));
+        Struct* s;
+
+        if (!rb_obj_is_kind_of(rbValue, rbffi_StructClass)) {
+            rb_raise(rb_eTypeError, "argument not an instance of struct");
+            return Qnil;
+        }
+
+        checkWrite(array->memory);
+        checkBounds(array->memory, offset, array->componentType->ffiType->size);
+
+        Data_Get_Struct(rbValue, Struct, s);
+        checkRead(s->pointer);
+        checkBounds(s->pointer, 0, array->componentType->ffiType->size);
+
+        memcpy(array->memory->address + offset, s->pointer->address, array->componentType->ffiType->size);
+
+    } else {
+        ArrayType* arrayType;
+        Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
+
+        rb_raise(rb_eArgError, "set not supported for %s", rb_obj_classname(arrayType->rbComponentType));
+        return Qnil;
+    }
 
     return rbValue;
 }
@@ -616,16 +683,30 @@ static VALUE
 inline_array_each(VALUE self)
 {
     InlineArray* array;
-    ArrayType* arrayType;
     
     int i;
 
     Data_Get_Struct(self, InlineArray, array);
-    Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
+    
+    if (array->op != NULL) {
+        for (i = 0; i < array->length; ++i) {
+            int offset = inline_array_offset(array, i);
+            rb_yield(array->op->get(array->memory, offset));
+        }
+    } else if (array->componentType->nativeType == NATIVE_STRUCT) {
+        for (i = 0; i < array->length; ++i) {
+            VALUE rbOffset = UINT2NUM(inline_array_offset(array, i));
+            VALUE rbLength = UINT2NUM(array->componentType->ffiType->size);
+            VALUE rbPointer = rb_funcall(array->rbMemory, rb_intern("slice"), 2, rbOffset, rbLength);
 
-    for (i = 0; i < arrayType->length; ++i) {
-    int offset = inline_array_offset(array, i);
-        rb_yield(array->op->get(array->memory, offset));
+            rb_yield(rb_class_new_instance(1, &rbPointer, ((StructByValue *) array->componentType)->rbStructClass));
+        }
+    } else {
+        ArrayType* arrayType;
+        Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
+
+        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(arrayType->rbComponentType));
+        return Qnil;
     }
 
     return self;
@@ -635,16 +716,14 @@ static VALUE
 inline_array_to_a(VALUE self)
 {
     InlineArray* array;
-    ArrayType* arrayType;
     VALUE obj;
     int i;
 
     Data_Get_Struct(self, InlineArray, array);
-    Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
-    obj = rb_ary_new2(arrayType->length);
+    obj = rb_ary_new2(array->length);
 
     
-    for (i = 0; i < arrayType->length; ++i) {
+    for (i = 0; i < array->length; ++i) {
         int offset = inline_array_offset(array, i);
         rb_ary_push(obj, array->op->get(array->memory, offset));
     }
@@ -656,19 +735,17 @@ static VALUE
 inline_array_to_s(VALUE self)
 {
     InlineArray* array;
-    ArrayType* arrayType;
     VALUE argv[2];
 
     Data_Get_Struct(self, InlineArray, array);
-    Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
-
-    if (arrayType->componentType->nativeType != NATIVE_INT8 && arrayType->componentType->nativeType != NATIVE_UINT8) {
-        rb_raise(rb_eNoMethodError, "to_s not defined for this array type");
-        return Qnil;
+ 
+    if (array->componentType->nativeType != NATIVE_INT8 && array->componentType->nativeType != NATIVE_UINT8) {
+        VALUE dummy = Qnil;
+        return rb_call_super(0, &dummy);
     }
 
     argv[0] = UINT2NUM(array->field->offset);
-    argv[1] = UINT2NUM(arrayType->length);
+    argv[1] = UINT2NUM(array->length);
 
     return rb_funcall2(array->rbMemory, rb_intern("get_string"), 2, argv);
 }
@@ -678,19 +755,11 @@ static VALUE
 inline_array_to_ptr(VALUE self)
 {
     InlineArray* array;
-    AbstractMemory* ptr;
-    VALUE rbOffset, rbPointer;
-
-    Data_Get_Struct(self, InlineArray, array);
-
-    rbOffset = UINT2NUM(array->field->offset);
-    rbPointer = rb_funcall2(array->rbMemory, rb_intern("+"), 1, &rbOffset);
-    Data_Get_Struct(rbPointer, AbstractMemory, ptr);
     
-    // Restrict the size of the pointer so ops like ptr.get_string(0) are bounds checked
-    ptr->size = MIN(ptr->size, array->field->type->ffiType->size);
+    Data_Get_Struct(self, InlineArray, array);
 
-    return rbPointer;
+    return rb_funcall(array->rbMemory, rb_intern("slice"), 2,
+        UINT2NUM(array->field->offset), UINT2NUM(array->arrayType->base.ffiType->size));
 }
 
 
@@ -711,6 +780,9 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rbffi_StructInlineArrayClass = rb_define_class_under(rbffi_StructClass, "InlineArray", rb_cObject);
     rb_global_variable(&rbffi_StructInlineArrayClass);
 
+    rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass,
+        "CharArray", rbffi_StructInlineArrayClass);
+    rb_global_variable(&rbffi_StructLayoutCharArrayClass);
 
 
     rb_define_alloc_func(StructClass, struct_allocate);
@@ -756,10 +828,11 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructInlineArrayClass, "each", inline_array_each, 0);
     rb_define_method(rbffi_StructInlineArrayClass, "size", inline_array_size, 0);
     rb_define_method(rbffi_StructInlineArrayClass, "to_a", inline_array_to_a, 0);
-    rb_define_method(rbffi_StructInlineArrayClass, "to_s", inline_array_to_s, 0);
-    rb_define_alias(rbffi_StructInlineArrayClass, "to_str", "to_s");
     rb_define_method(rbffi_StructInlineArrayClass, "to_ptr", inline_array_to_ptr, 0);
 
+    rb_define_method(rbffi_StructLayoutCharArrayClass, "to_s", inline_array_to_s, 0);
+    rb_define_alias(rbffi_StructLayoutCharArrayClass, "to_str", "to_s");
+
     id_pointer_ivar = rb_intern("@pointer");
     id_layout_ivar = rb_intern("@layout");
     id_layout = rb_intern("layout");