ffi 0.4.0-x86-mswin32 → 0.5.0-x86-mswin32

data/ext/ffi_c/Pointer.h

@@ -1,6 +1,33 @@
-
-#ifndef _POINTER_H
-#define	_POINTER_H
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ *
+ * 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.
+ * * The name of the author or authors may not 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.
+ */
+
+#ifndef RBFFI_POINTER_H
+#define	RBFFI_POINTER_H
 
 #ifdef	__cplusplus
 extern "C" {
@@ -9,17 +36,14 @@ extern "C" {
 #include "AbstractMemory.h"
 
 extern void rbffi_Pointer_Init(VALUE moduleFFI);
-extern void rbffi_NullPointer_Init(VALUE moduleFFI);
 extern VALUE rbffi_Pointer_NewInstance(void* addr);
 extern VALUE rbffi_PointerClass;
-extern VALUE rbffi_NullPointerClass;
 extern VALUE rbffi_NullPointerSingleton;
-extern MemoryOps rbffi_NullPointerOps;
 
 
 #ifdef	__cplusplus
 }
 #endif
 
-#endif	/* _POINTER_H */
+#endif	/* RBFFI_POINTER_H */
 

data/ext/ffi_c/Struct.c

@@ -1,4 +1,35 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ *
+ * 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.
+ * * The name of the author or authors may not 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.
+ */
+
 #include <sys/types.h>
+
+#include "Function.h"
 #include <sys/param.h>
 #include <stdint.h>
 #include <stdbool.h>
@@ -8,117 +39,46 @@
 #include "AbstractMemory.h"
 #include "Pointer.h"
 #include "MemoryPointer.h"
+#include "Function.h"
 #include "Types.h"
 #include "Struct.h"
+#include "StructByValue.h"
+#include "ArrayType.h"
 
-typedef struct StructField {
-    unsigned int type;
-    unsigned int offset;
-    unsigned int size;
-    unsigned int align;
-} StructField;
-
-typedef struct StructLayout {
-    VALUE rbFields;
-    unsigned int fieldCount;
-    int size;
-    int align;
-} StructLayout;
+#define FFI_ALIGN(v, a)  (((((size_t) (v))-1) | ((a)-1))+1)
 
 typedef struct StructLayoutBuilder {
-    unsigned int offset;
+    VALUE rbFieldNames;
+    VALUE rbFieldMap;
+    unsigned int size;
+    unsigned int alignment;
+    bool isUnion;
 } StructLayoutBuilder;
 
-static void struct_mark(Struct *);
-static void struct_layout_mark(StructLayout *);
-static inline MemoryOp* ptr_get_op(AbstractMemory* ptr, int type);
-
-VALUE rbffi_StructClass = Qnil;
-static VALUE StructLayoutClass = Qnil;
-static VALUE StructFieldClass = Qnil, StructLayoutBuilderClass = Qnil;
-static ID pointer_var_id = 0, layout_var_id = 0, SIZE_ID, ALIGN_ID, TYPE_ID;
-static ID get_id = 0, put_id = 0, to_ptr = 0, to_s = 0, layout_id = 0;
-
-static VALUE
-struct_field_allocate(VALUE klass)
-{
-    StructField* field;
-    return Data_Make_Struct(klass, StructField, NULL, -1, field);
-}
+typedef struct InlineArray_ {
+    VALUE rbMemory;
+    VALUE rbField;
 
-static VALUE
-struct_field_initialize(int argc, VALUE* argv, VALUE self)
-{
-    VALUE offset = Qnil, info = Qnil;
+    AbstractMemory* memory;
     StructField* field;
-    int nargs;
-
-    Data_Get_Struct(self, StructField, field);
-
-    nargs = rb_scan_args(argc, argv, "11", &offset, &info);
-    
-    field->offset = NUM2UINT(offset);
-    if (rb_const_defined(CLASS_OF(self), TYPE_ID)) {
-        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), TYPE_ID));
-    } else {
-        field->type = ~0;
-    }
-
-#ifdef notyet
-    field->size = NUM2UINT(rb_const_get(klass, SIZE_ID));
-    field->align = NUM2UINT(rb_const_get(klass, ALIGN_ID));
-#endif
-    rb_iv_set(self, "@off", offset);
-    rb_iv_set(self, "@info", info);
-
-    return self;
-}
+    MemoryOp *op;
+    Type* componentType;
+} InlineArray;
 
-static VALUE
-struct_field_offset(VALUE self)
-{
-    StructField* field;
-    Data_Get_Struct(self, StructField, field);
-    return UINT2NUM(field->offset);
-}
 
-static VALUE
-struct_field_get(VALUE self, VALUE pointer)
-{
-    StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
-
-    Data_Get_Struct(self, StructField, f);
-    op = ptr_get_op(memory, f->type);
-    if (op == NULL) {
-        VALUE name = rb_class_name(CLASS_OF(self));
-        rb_raise(rb_eArgError, "get not supported for %s", StringValueCStr(name));
-        return Qnil;
-    }
+static void struct_mark(Struct *);
+static void struct_layout_builder_mark(StructLayoutBuilder *);
+static void struct_layout_builder_free(StructLayoutBuilder *);
+static void inline_array_mark(InlineArray *);
 
-    return (*op->get)(memory, f->offset);
-}
+static inline int align(int offset, int align);
 
-static VALUE
-struct_field_put(VALUE self, VALUE pointer, VALUE value)
-{
-    StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
+VALUE rbffi_StructClass = Qnil;
+static VALUE StructLayoutBuilderClass = Qnil;
 
-    Data_Get_Struct(self, StructField, f);
-    op = ptr_get_op(memory, f->type);
-    if (op == NULL) {
-        VALUE name = rb_class_name(CLASS_OF(self));
-        rb_raise(rb_eArgError, "put not supported for %s", StringValueCStr(name));
-        return self;
-    }
-    
-    (*op->put)(memory, f->offset, value);
-
-    return self;
-}
+VALUE rbffi_StructInlineArrayClass = 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;
 
 static inline char*
 memory_address(VALUE self)
@@ -151,14 +111,14 @@ 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), layout_id, RARRAY_LEN(rest), RARRAY_PTR(rest));
-    } else if (rb_cvar_defined(klass, layout_var_id)) {
-        s->rbLayout = rb_cvar_get(klass, layout_var_id);
+        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");
     }
 
-    if (!rb_obj_is_kind_of(s->rbLayout, StructLayoutClass)) {
+    if (!rb_obj_is_kind_of(s->rbLayout, rbffi_StructLayoutClass)) {
         rb_raise(rb_eRuntimeError, "Invalid Struct layout");
     }
 
@@ -196,53 +156,17 @@ struct_field(Struct* s, VALUE fieldName)
         rb_raise(rb_eRuntimeError, "layout not set for Struct");
     }
 
-    rbField = rb_hash_aref(layout->rbFields, fieldName);
+    rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
     if (rbField == Qnil) {
-        VALUE str = rb_funcall2(fieldName, to_s, 0, NULL);
+        VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
         rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
     }
 
     return rbField;
 }
 
-static inline MemoryOp*
-ptr_get_op(AbstractMemory* ptr, int type)
-{
-    if (ptr == NULL || ptr->ops == NULL) {
-        return NULL;
-    }
-    switch (type) {
-        case NATIVE_INT8:
-            return ptr->ops->int8;
-        case NATIVE_UINT8:
-            return ptr->ops->uint8;
-        case NATIVE_INT16:
-            return ptr->ops->int16;
-        case NATIVE_UINT16:
-            return ptr->ops->uint16;
-        case NATIVE_INT32:
-            return ptr->ops->int32;
-        case NATIVE_UINT32:
-            return ptr->ops->uint32;
-        case NATIVE_INT64:
-            return ptr->ops->int64;
-        case NATIVE_UINT64:
-            return ptr->ops->uint64;
-        case NATIVE_FLOAT32:
-            return ptr->ops->float32;
-        case NATIVE_FLOAT64:
-            return ptr->ops->float64;
-        case NATIVE_POINTER:
-            return ptr->ops->pointer;
-        case NATIVE_STRING:
-            return ptr->ops->strptr;
-        default:
-            return NULL;
-    }
-}
-
 static VALUE
-struct_get_field(VALUE self, VALUE fieldName)
+struct_aref(VALUE self, VALUE fieldName)
 {
     Struct* s;
     VALUE rbField;
@@ -253,17 +177,17 @@ struct_get_field(VALUE self, VALUE fieldName)
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
 
-    op = ptr_get_op(s->pointer, f->type);
+    op = memory_get_op(s->pointer, f->type);
     if (op != NULL) {
         return (*op->get)(s->pointer, f->offset);
     }
     
     /* call up to the ruby code to fetch the value */
-    return rb_funcall2(rbField, get_id, 1, &s->rbPointer);
+    return rb_funcall2(rbField, id_get, 1, &s->rbPointer);
 }
 
 static VALUE
-struct_put_field(VALUE self, VALUE fieldName, VALUE value)
+struct_aset(VALUE self, VALUE fieldName, VALUE value)
 {
     Struct* s;
     VALUE rbField;
@@ -275,7 +199,7 @@ struct_put_field(VALUE self, VALUE fieldName, VALUE value)
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
 
-    op = ptr_get_op(s->pointer, f->type);
+    op = memory_get_op(s->pointer, f->type);
     if (op != NULL) {
         (*op->put)(s->pointer, f->offset, value);
         return self;
@@ -284,7 +208,7 @@ struct_put_field(VALUE self, VALUE fieldName, VALUE value)
     /* call up to the ruby code to set the value */
     argv[0] = s->rbPointer;
     argv[1] = value;
-    rb_funcall2(rbField, put_id, 2, argv);
+    rb_funcall2(rbField, id_put, 2, argv);
     
     return self;
 }
@@ -301,7 +225,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
     Data_Get_Struct(self, Struct, s);
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
-    rb_ivar_set(self, pointer_var_id, pointer);
+    rb_ivar_set(self, id_pointer_ivar, pointer);
 
     return self;
 }
@@ -322,12 +246,12 @@ struct_set_layout(VALUE self, VALUE layout)
     Struct* s;
     Data_Get_Struct(self, Struct, s);
 
-    if (!rb_obj_is_kind_of(layout, StructLayoutClass)) {
+    if (!rb_obj_is_kind_of(layout, rbffi_StructLayoutClass)) {
         rb_raise(rb_eArgError, "Invalid Struct layout");
     }
 
     Data_Get_Struct(layout, StructLayout, s->layout);
-    rb_ivar_set(self, layout_var_id, layout);
+    rb_ivar_set(self, id_layout_ivar, layout);
 
     return self;
 }
@@ -343,76 +267,451 @@ struct_get_layout(VALUE self)
 }
 
 static VALUE
-struct_layout_allocate(VALUE klass)
+struct_layout_builder_allocate(VALUE klass)
 {
-    StructLayout* layout;
+    StructLayoutBuilder* builder;
     VALUE obj;
-    
-    obj = Data_Make_Struct(klass, StructLayout, struct_layout_mark, -1, layout);
-    layout->rbFields = Qnil;
+
+    obj = Data_Make_Struct(klass, StructLayoutBuilder, struct_layout_builder_mark, struct_layout_builder_free, builder);
+
+    builder->size = 0;
+    builder->alignment = 1;
+    builder->isUnion = false;
+    builder->rbFieldNames = rb_ary_new();
+    builder->rbFieldMap = rb_hash_new();
 
     return obj;
 }
 
+static void
+struct_layout_builder_mark(StructLayoutBuilder* builder)
+{
+    rb_gc_mark(builder->rbFieldNames);
+    rb_gc_mark(builder->rbFieldMap);
+}
+
+static void
+struct_layout_builder_free(StructLayoutBuilder* builder)
+{
+    xfree(builder);
+}
+
 static VALUE
-struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
+struct_layout_builder_initialize(VALUE self)
 {
-    StructLayout* layout;
-    int i;
+    StructLayoutBuilder* builder;
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    return self;
+}
+
+static VALUE
+struct_layout_builder_get_size(VALUE self)
+{
+    StructLayoutBuilder* builder;
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    return UINT2NUM(builder->size);
+}
+
+static VALUE
+struct_layout_builder_set_size(VALUE self, VALUE rbSize)
+{
+    StructLayoutBuilder* builder;
+    unsigned int size = NUM2UINT(rbSize);
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+    builder->size = MAX(size, builder->size);
+
+    return UINT2NUM(builder->size);
+}
+
+static VALUE
+struct_layout_builder_get_alignment(VALUE self)
+{
+    StructLayoutBuilder* builder;
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    return UINT2NUM(builder->alignment);
+}
+
+static VALUE
+struct_layout_builder_set_alignment(VALUE self, VALUE rbAlign)
+{
+    StructLayoutBuilder* builder;
+    unsigned int align = NUM2UINT(rbAlign);
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+    builder->size = MAX(align, builder->alignment);
+
+    return UINT2NUM(builder->alignment);
+}
 
-    Data_Get_Struct(self, StructLayout, layout);
-    layout->rbFields = rb_hash_new();
-    layout->size = NUM2INT(size);
-    layout->align = NUM2INT(align);
+static VALUE
+struct_layout_builder_set_union(VALUE self, VALUE rbUnion)
+{
+    StructLayoutBuilder* builder;
+
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+    builder->isUnion = RTEST(rbUnion);
+
+    return rbUnion;
+}
+
+static VALUE
+struct_layout_builder_union_p(VALUE self)
+{
+    StructLayoutBuilder* builder;
+
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+
+    return builder->isUnion ? Qtrue : Qfalse;
+}
+
+static void
+store_field(StructLayoutBuilder* builder, VALUE rbName, VALUE rbField, 
+    unsigned int offset, unsigned int size, unsigned int alignment)
+{
+    rb_ary_push(builder->rbFieldNames, rbName);
+    rb_hash_aset(builder->rbFieldMap, rbName, rbField);
+
+    builder->alignment = MAX(builder->alignment, alignment);
+
+    if (builder->isUnion) {
+        builder->size = MAX(builder->size, size);
+    } else {
+        builder->size = MAX(builder->size, offset + size);
+    }
+}
+
+static int
+calculate_offset(StructLayoutBuilder* builder, int alignment, VALUE rbOffset)
+{
+    if (rbOffset != Qnil) {
+        return NUM2UINT(rbOffset);
+    } else {
+        return builder->isUnion ? 0 : align(builder->size, alignment);
+    }
+}
+
+static VALUE
+struct_layout_builder_add_field(int argc, VALUE* argv, VALUE self)
+{
+    StructLayoutBuilder* builder;
+    VALUE rbName = Qnil, rbType = Qnil, rbOffset = Qnil, rbField = Qnil;
+    unsigned int size, alignment, offset;
+    int nargs;
+
+    nargs = rb_scan_args(argc, argv, "21", &rbName, &rbType, &rbOffset);
     
-    rb_iv_set(self, "@field_names", field_names);
-    rb_iv_set(self, "@fields", fields);
-    rb_iv_set(self, "@size", size);
-    rb_iv_set(self, "@align", align);
-
-    for (i = 0; i < RARRAY_LEN(field_names); ++i) {
-        VALUE name = RARRAY_PTR(field_names)[i];
-        VALUE field = rb_hash_aref(fields, name);
-        if (TYPE(field) != T_DATA || !rb_obj_is_kind_of(field, StructFieldClass)) {
-            rb_raise(rb_eArgError, "Invalid field");
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    alignment = NUM2UINT(rb_funcall2(rbType, rb_intern("alignment"), 0, NULL));
+    size = NUM2UINT(rb_funcall2(rbType, rb_intern("size"), 0, NULL));
+
+    offset = calculate_offset(builder, alignment, rbOffset);
+
+    //
+    // If a primitive type was passed in as the type arg, try and convert
+    //
+    if (!rb_obj_is_kind_of(rbType, rbffi_StructLayoutFieldClass)) {
+        VALUE fargv[3], rbFieldClass;
+        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;
+        } else if (rb_obj_is_kind_of(rbType, rbffi_ArrayTypeClass)) {
+            rbFieldClass = rbffi_StructLayoutArrayFieldClass;
+        } else {
+            rbFieldClass = rbffi_StructLayoutFieldClass;
         }
-        rb_hash_aset(layout->rbFields, name, field);
+
+        rbField = rb_class_new_instance(3, fargv, rbFieldClass);
+    } else {
+        rbField = rbType;
+    }
+
+    store_field(builder, rbName, rbField, offset, size, alignment);
+    
+    return self;
+}
+
+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 fargv[3];
+    unsigned int size, alignment, offset;
+    int nargs;
+
+    nargs = rb_scan_args(argc, argv, "21", &rbName, &rbStructClass, &rbOffset);
+
+    if (!rb_obj_is_instance_of(rbStructClass, rb_cClass) || !rb_class_inherited(rbStructClass, rbffi_StructClass)) {
+        rb_raise(rb_eTypeError, "wrong argument type.  Expected subclass of FFI::Struct");
     }
+
+    rbType = rb_class_new_instance(1, &rbStructClass, rbffi_StructByValueClass);
+
+    alignment = NUM2UINT(rb_funcall2(rbType, rb_intern("alignment"), 0, NULL));
+    size = NUM2UINT(rb_funcall2(rbType, rb_intern("size"), 0, NULL));
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    offset = calculate_offset(builder, alignment, rbOffset);
+
+    fargv[0] = rbName;
+    fargv[1] = UINT2NUM(offset);
+    fargv[2] = rbType;
+    rbField = rb_class_new_instance(3, fargv, rbffi_StructLayoutStructFieldClass);
+    store_field(builder, rbName, rbField, offset, size, alignment);
+
     return self;
 }
 
 static VALUE
-struct_layout_aref(VALUE self, VALUE field)
+struct_layout_builder_add_array(int argc, VALUE* argv, VALUE self)
 {
-    StructLayout* layout;
+    StructLayoutBuilder* builder;
+    VALUE rbName = Qnil, rbType = Qnil, rbLength = Qnil, rbOffset = Qnil, rbField;
+    VALUE fargv[3], aargv[2];
+    unsigned int size, alignment, offset;
+    int nargs;
+
+    nargs = rb_scan_args(argc, argv, "31", &rbName, &rbType, &rbLength, &rbOffset);
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    alignment = NUM2UINT(rb_funcall2(rbType, rb_intern("alignment"), 0, NULL));
+    size = NUM2UINT(rb_funcall2(rbType, rb_intern("size"), 0, NULL)) * NUM2UINT(rbLength);
 
-    Data_Get_Struct(self, StructLayout, layout);
+    offset = calculate_offset(builder, alignment, rbOffset);
 
-    return rb_hash_aref(layout->rbFields, field);
+    aargv[0] = rbType;
+    aargv[1] = rbLength;
+    fargv[0] = rbName;
+    fargv[1] = UINT2NUM(offset);
+    fargv[2] = rb_class_new_instance(2, aargv, rbffi_ArrayTypeClass);
+    rbField = rb_class_new_instance(3, fargv, rbffi_StructLayoutArrayFieldClass);
+
+    store_field(builder, rbName, rbField, offset, size, alignment);
+
+    return self;
+}
+
+static inline int
+align(int offset, int align)
+{
+    return align + ((offset - 1) & ~(align - 1));
 }
 
+static VALUE
+struct_layout_builder_build(VALUE self)
+{
+    StructLayoutBuilder* builder;
+    VALUE argv[4];
+
+    Data_Get_Struct(self, StructLayoutBuilder, builder);
+
+    argv[0] = builder->rbFieldNames;
+    argv[1] = builder->rbFieldMap;
+    argv[2] = UINT2NUM(align(builder->size, builder->alignment)); // tail padding
+    argv[3] = UINT2NUM(builder->alignment);
+
+    return rb_class_new_instance(4, argv, rbffi_StructLayoutClass);
+}
+
+static VALUE
+inline_array_allocate(VALUE klass)
+{
+    InlineArray* array;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, InlineArray, inline_array_mark, -1, array);
+    array->rbField = Qnil;
+    array->rbMemory = Qnil;
+
+    return obj;
+}
 
 static void
-struct_layout_mark(StructLayout *layout)
+inline_array_mark(InlineArray* array)
+{
+    rb_gc_mark(array->rbField);
+    rb_gc_mark(array->rbMemory);
+}
+
+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);
+    
+    array->op = memory_get_op(array->memory, array->componentType);
+    if (array->op == NULL) {
+        rb_raise(rb_eRuntimeError, "invalid memory ops");
+    }
+
+    return self;
+}
+
+static VALUE
+inline_array_size(VALUE self)
+{
+    InlineArray* array;
+
+    Data_Get_Struct(self, InlineArray, array);
+
+    return UINT2NUM(array->field->type->ffiType->size);
+}
+
+static int
+inline_array_offset(InlineArray* array, unsigned int index)
 {
-    rb_gc_mark(layout->rbFields);
+    return array->field->offset + (index * array->componentType->ffiType->size);
 }
 
+static VALUE
+inline_array_aref(VALUE self, VALUE rbIndex)
+{
+    InlineArray* array;
+
+    Data_Get_Struct(self, InlineArray, array);
+
+    return array->op->get(array->memory, inline_array_offset(array, NUM2UINT(rbIndex)));
+}
+
+static VALUE
+inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
+{
+    InlineArray* array;
+
+    Data_Get_Struct(self, InlineArray, array);
+
+    array->op->put(array->memory, inline_array_offset(array, NUM2UINT(rbIndex)),
+        rbValue);
+
+    return rbValue;
+}
+
+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);
+
+    for (i = 0; i < arrayType->length; ++i) {
+    int offset = inline_array_offset(array, i);
+        rb_yield(array->op->get(array->memory, offset));
+    }
+
+    return self;
+}
+
+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);
+
+    
+    for (i = 0; i < arrayType->length; ++i) {
+        int offset = inline_array_offset(array, i);
+        rb_ary_push(obj, array->op->get(array->memory, offset));
+    }
+
+    return obj;
+}
+
+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;
+    }
+
+    argv[0] = UINT2NUM(array->field->offset);
+    argv[1] = UINT2NUM(arrayType->length);
+
+    return rb_funcall2(array->rbMemory, rb_intern("get_string"), 2, argv);
+}
+
+
+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);
+
+    return rbPointer;
+}
+
+
 void
 rbffi_Struct_Init(VALUE moduleFFI)
 {
-    VALUE klass, StructClass;
+    VALUE StructClass;
+
+    rbffi_StructLayout_Init(moduleFFI);
+
     rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
     rb_global_variable(&rbffi_StructClass);
 
-    StructLayoutClass = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
-    rb_global_variable(&StructLayoutClass);
 
     StructLayoutBuilderClass = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
     rb_global_variable(&StructLayoutBuilderClass);
 
-    StructFieldClass = rb_define_class_under(StructLayoutBuilderClass, "Field", rb_cObject);
-    rb_global_variable(&StructFieldClass);
+    rbffi_StructInlineArrayClass = rb_define_class_under(rbffi_StructClass, "InlineArray", rb_cObject);
+    rb_global_variable(&rbffi_StructInlineArrayClass);
+
+
 
     rb_define_alloc_func(StructClass, struct_allocate);
     rb_define_method(StructClass, "initialize", struct_initialize, -1);
@@ -430,48 +729,42 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rb_define_method(StructClass, "layout", struct_get_layout, 0);
     rb_define_private_method(StructClass, "layout=", struct_set_layout, 1);
 
-    rb_define_method(StructClass, "[]", struct_get_field, 1);
-    rb_define_method(StructClass, "[]=", struct_put_field, 2);
+    rb_define_method(StructClass, "[]", struct_aref, 1);
+    rb_define_method(StructClass, "[]=", struct_aset, 2);
     
-    rb_define_alloc_func(StructFieldClass, struct_field_allocate);
-    rb_define_method(StructFieldClass, "initialize", struct_field_initialize, -1);
-    rb_define_method(StructFieldClass, "offset", struct_field_offset, 0);
-    rb_define_method(StructFieldClass, "put", struct_field_put, 2);
-    rb_define_method(StructFieldClass, "get", struct_field_get, 1);
-
-    rb_define_alloc_func(StructLayoutClass, struct_layout_allocate);
-    rb_define_method(StructLayoutClass, "initialize", struct_layout_initialize, 4);
-    rb_define_method(StructLayoutClass, "[]", struct_layout_aref, 1);
-
-    pointer_var_id = rb_intern("@pointer");
-    layout_var_id = rb_intern("@layout");
-    layout_id = rb_intern("layout");
-    get_id = rb_intern("get");
-    put_id = rb_intern("put");
-    to_ptr = rb_intern("to_ptr");
-    to_s = rb_intern("to_s");
-    SIZE_ID = rb_intern("SIZE");
-    ALIGN_ID = rb_intern("ALIGN");
-    TYPE_ID = rb_intern("TYPE");
-#undef FIELD
-#define FIELD(name, typeName, nativeType, T) do { \
-    typedef struct { char c; T v; } s; \
-        klass = rb_define_class_under(StructLayoutBuilderClass, #name, StructFieldClass); \
-        rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)))); \
-        rb_define_const(klass, "SIZE", INT2NUM(sizeof(T))); \
-        rb_define_const(klass, "TYPE", INT2NUM(nativeType)); \
-    } while(0)
     
-    FIELD(Signed8, int8, NATIVE_INT8, char);
-    FIELD(Unsigned8, uint8, NATIVE_UINT8, unsigned char);
-    FIELD(Signed16, int16, NATIVE_INT16, short);
-    FIELD(Unsigned16, uint16, NATIVE_UINT16, unsigned short);
-    FIELD(Signed32, int32, NATIVE_INT32, int);
-    FIELD(Unsigned32, uint32, NATIVE_UINT32, unsigned int);
-    FIELD(Signed64, int64, NATIVE_INT64, long long);
-    FIELD(Unsigned64, uint64, NATIVE_UINT64, unsigned long long);
-    FIELD(FloatField, float32, NATIVE_FLOAT32, float);
-    FIELD(DoubleField, float64, NATIVE_FLOAT64, double);
-    FIELD(PointerField, pointer, NATIVE_POINTER, char *);
-    FIELD(StringField, string, NATIVE_STRING, char *);
+
+    rb_define_alloc_func(StructLayoutBuilderClass, struct_layout_builder_allocate);
+    rb_define_method(StructLayoutBuilderClass, "initialize", struct_layout_builder_initialize, 0);
+    rb_define_method(StructLayoutBuilderClass, "build", struct_layout_builder_build, 0);
+
+    rb_define_method(StructLayoutBuilderClass, "alignment", struct_layout_builder_get_alignment, 0);
+    rb_define_method(StructLayoutBuilderClass, "alignment=", struct_layout_builder_set_alignment, 1);
+    rb_define_method(StructLayoutBuilderClass, "size", struct_layout_builder_get_size, 0);
+    rb_define_method(StructLayoutBuilderClass, "size=", struct_layout_builder_set_size, 1);
+    rb_define_method(StructLayoutBuilderClass, "union=", struct_layout_builder_set_union, 1);
+    rb_define_method(StructLayoutBuilderClass, "union?", struct_layout_builder_union_p, 0);
+    rb_define_method(StructLayoutBuilderClass, "add_field", struct_layout_builder_add_field, -1);
+    rb_define_method(StructLayoutBuilderClass, "add_array", struct_layout_builder_add_array, -1);
+    rb_define_method(StructLayoutBuilderClass, "add_struct", struct_layout_builder_add_struct, -1);
+
+    rb_include_module(rbffi_StructInlineArrayClass, rb_mEnumerable);
+    rb_define_alloc_func(rbffi_StructInlineArrayClass, inline_array_allocate);
+    rb_define_method(rbffi_StructInlineArrayClass, "initialize", inline_array_initialize, 2);
+    rb_define_method(rbffi_StructInlineArrayClass, "[]", inline_array_aref, 1);
+    rb_define_method(rbffi_StructInlineArrayClass, "[]=", inline_array_aset, 2);
+    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);
+
+    id_pointer_ivar = rb_intern("@pointer");
+    id_layout_ivar = rb_intern("@layout");
+    id_layout = rb_intern("layout");
+    id_get = rb_intern("get");
+    id_put = rb_intern("put");
+    id_to_ptr = rb_intern("to_ptr");
+    id_to_s = rb_intern("to_s");
 }