ffi 0.5.4-x86-mingw32 → 0.6.3-x86-mingw32

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;
@@ -363,7 +374,7 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
                 param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
                 break;
             case NATIVE_BOOL:
-                param = (*(void **) parameters[i]) ? Qtrue : Qfalse;
+                param = (*(uint8_t *) parameters[i]) ? Qtrue : Qfalse;
                 break;
 
             case NATIVE_FUNCTION:
@@ -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;
@@ -411,8 +428,9 @@ callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
                 *((void **) retval) = NULL;
             }
             break;
+
         case NATIVE_BOOL:
-            *((ffi_sarg *) retval) = TYPE(rbReturnValue) == T_TRUE ? 1 : 0;
+            *((ffi_arg *) retval) = rbReturnValue == Qtrue;
             break;
 
         case NATIVE_FUNCTION:

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;

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,12 +63,16 @@ typedef struct InlineArray_ {
     StructField* field;
     MemoryOp *op;
     Type* componentType;
+    ArrayType* arrayType;
+    unsigned int length;
 } InlineArray;
 
 
 static void struct_mark(Struct *);
 static void struct_layout_builder_mark(StructLayoutBuilder *);
 static void struct_layout_builder_free(StructLayoutBuilder *);
+static VALUE struct_class_layout(VALUE klass);
+static void struct_malloc(Struct* s);
 static void inline_array_mark(InlineArray *);
 
 static inline int align(int offset, int align);
@@ -77,6 +81,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;
 
@@ -112,10 +118,8 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     /* Call up into ruby code to adjust the layout */
     if (nargs > 1) {
         s->rbLayout = rb_funcall2(CLASS_OF(self), id_layout, RARRAY_LEN(rest), RARRAY_PTR(rest));
-    } else if (rb_cvar_defined(klass, id_layout_ivar)) {
-        s->rbLayout = rb_cvar_get(klass, id_layout_ivar);
     } else {
-        rb_raise(rb_eRuntimeError, "No Struct layout configured");
+        s->rbLayout = struct_class_layout(klass);
     }
 
     if (!rb_obj_is_kind_of(s->rbLayout, rbffi_StructLayoutClass)) {
@@ -128,16 +132,72 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
     } else {
-        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
-        s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
+        struct_malloc(s);
+    }
+
+    return self;
+}
+
+static VALUE
+struct_class_layout(VALUE klass)
+{
+    VALUE layout;
+    if (!rb_cvar_defined(klass, id_layout_ivar)) {
+        rb_raise(rb_eRuntimeError, "no Struct layout configured for %s", rb_class2name(klass));
     }
 
-    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));
+    layout = rb_cvar_get(klass, id_layout_ivar);
+    if (!rb_obj_is_kind_of(layout, rbffi_StructLayoutClass)) {
+        rb_raise(rb_eRuntimeError, "invalid Struct layout for %s", rb_class2name(klass));
     }
 
-    return self;
+    return layout;
+}
+
+static StructLayout*
+struct_layout(VALUE self)
+{
+    Struct* s = (Struct *) DATA_PTR(self);
+    if (s->layout != NULL) {
+        return s->layout;
+    }
+
+    if (s->layout == NULL) {
+        s->rbLayout = struct_class_layout(CLASS_OF(self));
+        Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
+    }
+
+    return s->layout;
+}
+
+static Struct*
+struct_validate(VALUE self)
+{
+    Struct* s;
+    Data_Get_Struct(self, Struct, s);
+
+    if (struct_layout(self) == NULL) {
+        rb_raise(rb_eRuntimeError, "struct layout == null");
+    }
+
+    if (s->pointer == NULL) {
+        struct_malloc(s);
+    }
+
+    return s;
+}
+
+static void
+struct_malloc(Struct* s)
+{
+    if (s->rbPointer == Qnil) {
+        s->rbPointer = rbffi_MemoryPointer_NewInstance(s->layout->size, 1, true);
+
+    } else if (!rb_obj_is_kind_of(s->rbPointer, rbffi_AbstractMemoryClass)) {
+        rb_raise(rb_eRuntimeError, "invalid pointer in struct");
+    }
+
+    s->pointer = (AbstractMemory *) DATA_PTR(s->rbPointer);
 }
 
 static void
@@ -152,9 +212,6 @@ struct_field(Struct* s, VALUE fieldName)
 {
     StructLayout* layout = s->layout;
     VALUE rbField;
-    if (layout == NULL) {
-        rb_raise(rb_eRuntimeError, "layout not set for Struct");
-    }
 
     rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
     if (rbField == Qnil) {
@@ -171,19 +228,23 @@ struct_aref(VALUE self, VALUE fieldName)
     Struct* s;
     VALUE rbField;
     StructField* f;
-    MemoryOp* op;
 
-    Data_Get_Struct(self, Struct, s);
+    s = struct_validate(self);
+
     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,37 +253,53 @@ 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);
+
+    s = struct_validate(self);
+
     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
 struct_set_pointer(VALUE self, VALUE pointer)
 {
     Struct* s;
+    StructLayout* layout;
+    AbstractMemory* memory;
 
     if (!rb_obj_is_kind_of(pointer, rbffi_AbstractMemoryClass)) {
-        rb_raise(rb_eArgError, "Invalid pointer");
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected Pointer or Buffer)",
+                rb_obj_classname(pointer));
+        return Qnil;
     }
 
+    
     Data_Get_Struct(self, Struct, s);
+    Data_Get_Struct(pointer, AbstractMemory, memory);
+    layout = struct_layout(self);
+
+    if (layout->base.ffiType->size > memory->size) {
+        rb_raise(rb_eArgError, "memory of %d bytes too small for struct %s (expected at least %d)",
+                memory->size, rb_obj_classname(self), layout->base.ffiType->size);
+    }
+    
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
     rb_ivar_set(self, id_pointer_ivar, pointer);
@@ -247,7 +324,9 @@ struct_set_layout(VALUE self, VALUE layout)
     Data_Get_Struct(self, Struct, s);
 
     if (!rb_obj_is_kind_of(layout, rbffi_StructLayoutClass)) {
-        rb_raise(rb_eArgError, "Invalid Struct layout");
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+                rb_obj_classname(layout), rb_class2name(rbffi_StructLayoutClass));
+        return Qnil;
     }
 
     Data_Get_Struct(layout, StructLayout, s->layout);
@@ -425,16 +504,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 +544,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 +568,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 +657,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 +684,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 +700,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 +722,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 +758,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);
+
+            rb_yield(rb_class_new_instance(1, &rbPointer, ((StructByValue *) array->componentType)->rbStructClass));
+        }
+    } else {
+        ArrayType* arrayType;
+        Data_Get_Struct(array->field->rbType, ArrayType, arrayType);
 
-    for (i = 0; i < arrayType->length; ++i) {
-    int offset = inline_array_offset(array, i);
-        rb_yield(array->op->get(array->memory, offset));
+        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(arrayType->rbComponentType));
+        return Qnil;
     }
 
     return self;
@@ -635,16 +791,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 +810,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 +830,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 +855,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 +903,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");