ffi 0.3.0 → 0.4.0

data/ext/ffi_c/Struct.c

@@ -29,30 +29,21 @@ typedef struct StructLayoutBuilder {
     unsigned int offset;
 } StructLayoutBuilder;
 
-static void struct_field_mark(StructField *);
-static void struct_field_free(StructField *);
 static void struct_mark(Struct *);
-static void struct_free(Struct *);
 static void struct_layout_mark(StructLayout *);
-static void struct_layout_free(StructLayout *);
+static inline MemoryOp* ptr_get_op(AbstractMemory* ptr, int type);
 
-VALUE rb_FFI_Struct_class = Qnil;
-static VALUE classStruct = Qnil, classStructLayout = Qnil;
-static VALUE classStructField = Qnil, classStructLayoutBuilder = Qnil;
-static ID pointerID = 0, layoutID = 0, SIZE_ID, ALIGN_ID;
-static ID getID = 0, putID = 0, to_ptr = 0;
-
-#define FIELD_CAST(obj) ((StructField *)((TYPE(obj) == T_DATA && rb_obj_is_kind_of(obj, classStructField)) \
-    ? DATA_PTR(obj) : (rb_raise(rb_eArgError, "StructField expected"), NULL)))
-
-#define LAYOUT_CAST(obj) ((StructLayout *)((TYPE(obj) == T_DATA && rb_obj_is_kind_of(obj, classStructLayout)) \
-    ? DATA_PTR(obj) : (rb_raise(rb_eArgError, "StructLayout expected"), NULL)))
+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, struct_field_mark, struct_field_free, field);
+    return Data_Make_Struct(klass, StructField, NULL, -1, field);
 }
 
 static VALUE
@@ -67,17 +58,19 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
     nargs = rb_scan_args(argc, argv, "11", &offset, &info);
     
     field->offset = NUM2UINT(offset);
-    if (rb_const_defined(CLASS_OF(self), rb_intern("TYPE"))) {
-        field->type = NUM2UINT(rb_const_get(CLASS_OF(self), rb_intern("TYPE")));
+    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, rb_intern("SIZE")));
-    field->align = NUM2UINT(rb_const_get(klass, rb_intern("ALIGN")));
+    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;
 }
 
@@ -89,135 +82,67 @@ struct_field_offset(VALUE self)
     return UINT2NUM(field->offset);
 }
 
-static void
-struct_field_mark(StructField *f)
-{
-}
-static void
-struct_field_free(StructField *f)
+static VALUE
+struct_field_get(VALUE self, VALUE pointer)
 {
-    if (f != NULL) {
-        xfree(f);
+    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 inline char*
-memory_address(VALUE self)
-{
-    return ((AbstractMemory *)DATA_PTR((self)))->address;
+    return (*op->get)(memory, f->offset);
 }
 
-static inline char*
-pointer_native(VALUE value)
+static VALUE
+struct_field_put(VALUE self, VALUE pointer, VALUE value)
 {
-    const int type = TYPE(value);
-
-    if (rb_obj_is_kind_of(value, rb_FFI_Pointer_class) && type == T_DATA) {
-        return memory_address(value);
-    } else if (type == T_NIL) {
-        return NULL;
-    } else if (type == T_FIXNUM) {
-        return (char *)(uintptr_t) FIX2INT(value);
-    } else if (type == T_BIGNUM) {
-        return (char *)(uintptr_t) NUM2ULL(value);
-    } else if (rb_respond_to(value, to_ptr)) {
-        VALUE ptr = rb_funcall2(value, to_ptr, 0, NULL);
-        if (rb_obj_is_kind_of(ptr, rb_FFI_Pointer_class) && TYPE(ptr) == T_DATA) {
-            return memory_address(ptr);
-        } else {
-            rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
-        }
-    } else {
-        rb_raise(rb_eArgError, "value is not a 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, "put not supported for %s", StringValueCStr(name));
+        return self;
     }
-}
+    
+    (*op->put)(memory, f->offset, value);
 
-static inline VALUE
-pointer_new(char* value)
-{
-    return rb_FFI_Pointer_new(value);
+    return self;
 }
 
 static inline char*
-string_to_native(VALUE value)
-{
-    rb_raise(rb_eArgError, "Cannot set :string fields");
-}
-
-static inline VALUE
-string_from_native(char* value)
+memory_address(VALUE self)
 {
-    return value != NULL ? rb_tainted_str_new2(value) : Qnil;
-}
-
-#define FIELD_OP(name, type, toNative, fromNative) \
-static VALUE struct_field_put_##name(VALUE self, VALUE pointer, VALUE value); \
-static inline void ptr_put_##name(AbstractMemory* ptr, StructField* field, VALUE value); \
-static inline VALUE ptr_get_##name(AbstractMemory* ptr, StructField* field); \
-static inline void \
-ptr_put_##name(AbstractMemory* ptr, StructField* field, VALUE value) \
-{ \
-    type tmp = toNative(value); \
-    memcpy(ptr->address + field->offset, &tmp, sizeof(tmp)); \
-} \
-static inline VALUE \
-ptr_get_##name(AbstractMemory* ptr, StructField* field) \
-{ \
-    type tmp; \
-    memcpy(&tmp, ptr->address + field->offset, sizeof(tmp)); \
-    return fromNative(tmp); \
-} \
-static VALUE \
-struct_field_put_##name(VALUE self, VALUE pointer, VALUE value) \
-{ \
-    StructField* f;  Data_Get_Struct(self, StructField, f); \
-    ptr_put_##name(MEMORY(pointer), f, value); \
-    return self; \
-} \
-static VALUE struct_field_get_##name(VALUE self, VALUE pointer); \
-static VALUE \
-struct_field_get_##name(VALUE self, VALUE pointer) \
-{ \
-    StructField* f;  Data_Get_Struct(self, StructField, f); \
-    return ptr_get_##name(MEMORY(pointer), f); \
+    return ((AbstractMemory *)DATA_PTR((self)))->address;
 }
 
-FIELD_OP(int8, int8_t, NUM2INT, INT2NUM);
-FIELD_OP(uint8, uint8_t, NUM2UINT, UINT2NUM);
-FIELD_OP(int16, int16_t, NUM2INT, INT2NUM);
-FIELD_OP(uint16, uint16_t, NUM2UINT, UINT2NUM);
-FIELD_OP(int32, int32_t, NUM2INT, INT2NUM);
-FIELD_OP(uint32, uint32_t, NUM2UINT, UINT2NUM);
-FIELD_OP(int64, int64_t, NUM2LL, LL2NUM);
-FIELD_OP(uint64, uint64_t, NUM2ULL, ULL2NUM);
-FIELD_OP(float32, float, NUM2DBL, rb_float_new);
-FIELD_OP(float64, double, NUM2DBL, rb_float_new);
-FIELD_OP(pointer, char*, pointer_native, pointer_new);
-FIELD_OP(string, char*, string_to_native, string_from_native);
-
 static VALUE
 struct_allocate(VALUE klass)
 {
     Struct* s;
-    VALUE retval = Data_Make_Struct(klass, Struct, struct_mark, struct_free, s);
+    VALUE obj = Data_Make_Struct(klass, Struct, struct_mark, -1, s);
     
     s->rbPointer = Qnil;
-    s->pointer = NULL;
     s->rbLayout = Qnil;
-    s->layout = NULL;
 
-    if (rb_cvar_defined(klass, layoutID)) {
-        s->rbLayout = rb_cvar_get(klass, layoutID);
-        Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
-    }
-    return retval;
+    return obj;
 }
 
 static VALUE
 struct_initialize(int argc, VALUE* argv, VALUE self)
 {
     Struct* s;
-    VALUE rbPointer = Qnil, rest = Qnil;
+    VALUE rbPointer = Qnil, rest = Qnil, klass = CLASS_OF(self);
     int nargs;
 
     Data_Get_Struct(self, Struct, s);
@@ -226,38 +151,40 @@ 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), rb_intern("layout"), RARRAY_LEN(rest), RARRAY_PTR(rest));
-        if (!rb_obj_is_kind_of(s->rbLayout, classStructLayout)) {
-            rb_raise(rb_eRuntimeError, "Invalid Struct layout");
-        }
+        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);
+    } else {
+        rb_raise(rb_eRuntimeError, "No Struct layout configured");
+    }
 
-        Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
+    if (!rb_obj_is_kind_of(s->rbLayout, StructLayoutClass)) {
+        rb_raise(rb_eRuntimeError, "Invalid Struct layout");
     }
+
+    Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
     
-    if (rbPointer == Qnil) {
-        rbPointer = rb_FFI_MemoryPointer_new(s->layout->size, 1, true);
+    if (rbPointer != Qnil) {
+        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);
     }
-    
-    s->rbPointer = rbPointer;
-    s->pointer = MEMORY(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;
 }
 
 static void
 struct_mark(Struct *s)
 {
-    if (s->rbPointer != Qnil) {
-        rb_gc_mark(s->rbPointer);
-    }
-    if (s->rbLayout != Qnil) {
-        rb_gc_mark(s->rbLayout);
-    }
-}
-
-static void struct_free(Struct *s)
-{
-    xfree(s);
+    rb_gc_mark(s->rbPointer);
+    rb_gc_mark(s->rbLayout);
 }
 
 static VALUE
@@ -268,54 +195,71 @@ struct_field(Struct* s, VALUE fieldName)
     if (layout == NULL) {
         rb_raise(rb_eRuntimeError, "layout not set for Struct");
     }
+
     rbField = rb_hash_aref(layout->rbFields, fieldName);
     if (rbField == Qnil) {
-        VALUE str = rb_funcall2(fieldName, rb_intern("to_s"), 0, NULL);
+        VALUE str = rb_funcall2(fieldName, to_s, 0, NULL);
         rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
     }
+
     return rbField;
 }
 
-static VALUE
-struct_get_field(VALUE self, VALUE fieldName)
+static inline MemoryOp*
+ptr_get_op(AbstractMemory* ptr, int type)
 {
-    Struct* s;
-    VALUE rbField;
-    StructField* f;
-
-    Data_Get_Struct(self, Struct, s);
-    rbField = struct_field(s, fieldName);
-    f = FIELD_CAST(rbField);
-
-    switch (f->type) {
+    if (ptr == NULL || ptr->ops == NULL) {
+        return NULL;
+    }
+    switch (type) {
         case NATIVE_INT8:
-            return ptr_get_int8(s->pointer, f);
+            return ptr->ops->int8;
         case NATIVE_UINT8:
-            return ptr_get_uint8(s->pointer, f);
+            return ptr->ops->uint8;
         case NATIVE_INT16:
-            return ptr_get_int16(s->pointer, f);
+            return ptr->ops->int16;
         case NATIVE_UINT16:
-            return ptr_get_uint16(s->pointer, f);
+            return ptr->ops->uint16;
         case NATIVE_INT32:
-            return ptr_get_int32(s->pointer, f);
+            return ptr->ops->int32;
         case NATIVE_UINT32:
-            return ptr_get_uint32(s->pointer, f);
+            return ptr->ops->uint32;
         case NATIVE_INT64:
-            return ptr_get_int64(s->pointer, f);
+            return ptr->ops->int64;
         case NATIVE_UINT64:
-            return ptr_get_uint64(s->pointer, f);
+            return ptr->ops->uint64;
         case NATIVE_FLOAT32:
-            return ptr_get_float32(s->pointer, f);
+            return ptr->ops->float32;
         case NATIVE_FLOAT64:
-            return ptr_get_float64(s->pointer, f);
+            return ptr->ops->float64;
         case NATIVE_POINTER:
-            return ptr_get_pointer(s->pointer, f);
+            return ptr->ops->pointer;
         case NATIVE_STRING:
-            return ptr_get_string(s->pointer, f);
+            return ptr->ops->strptr;
         default:
-            /* call up to the ruby code to fetch the value */
-            return rb_funcall2(rbField, getID, 1, &s->rbPointer);
+            return NULL;
+    }
+}
+
+static VALUE
+struct_get_field(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 = ptr_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);
 }
 
 static VALUE
@@ -324,55 +268,24 @@ struct_put_field(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 = FIELD_CAST(rbField);
+    f = (StructField *) DATA_PTR(rbField);
 
-    switch (f->type) {
-        case NATIVE_INT8:
-            ptr_put_int8(s->pointer, f, value);
-            break;
-        case NATIVE_UINT8:
-            ptr_put_uint8(s->pointer, f, value);
-            break;
-        case NATIVE_INT16:
-            ptr_put_int16(s->pointer, f, value);
-            break;
-        case NATIVE_UINT16:
-            ptr_put_uint16(s->pointer, f, value);
-            break;
-        case NATIVE_INT32:
-            ptr_put_int32(s->pointer, f, value);
-            break;
-        case NATIVE_UINT32:
-            ptr_put_uint32(s->pointer, f, value);
-            break;
-        case NATIVE_INT64:
-            ptr_put_int64(s->pointer, f, value);
-            break;
-        case NATIVE_UINT64:
-            ptr_put_uint64(s->pointer, f, value);
-            break;
-        case NATIVE_FLOAT32:
-            ptr_put_float32(s->pointer, f, value);
-            break;
-        case NATIVE_FLOAT64:
-            ptr_put_float64(s->pointer, f, value);
-            break;
-        case NATIVE_POINTER:
-            ptr_put_pointer(s->pointer, f, value);
-            break;
-        case NATIVE_STRING:
-            rb_raise(rb_eArgError, "Cannot set :string fields");
-        default:
-            /* call up to the ruby code to set the value */
-            argv[0] = s->rbPointer;
-            argv[1] = value;
-            rb_funcall2(rbField, putID, 2, argv);
-            break;
+    op = ptr_get_op(s->pointer, f->type);
+    if (op != NULL) {
+        (*op->put)(s->pointer, f->offset, value);
+        return self;
     }
+    
+    /* call up to the ruby code to set the value */
+    argv[0] = s->rbPointer;
+    argv[1] = value;
+    rb_funcall2(rbField, put_id, 2, argv);
+    
     return self;
 }
 
@@ -381,14 +294,15 @@ struct_set_pointer(VALUE self, VALUE pointer)
 {
     Struct* s;
 
-    if (!rb_obj_is_kind_of(pointer, rb_FFI_AbstractMemory_class)) {
+    if (!rb_obj_is_kind_of(pointer, rbffi_AbstractMemoryClass)) {
         rb_raise(rb_eArgError, "Invalid pointer");
     }
 
     Data_Get_Struct(self, Struct, s);
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
-    rb_ivar_set(self, pointerID, pointer);
+    rb_ivar_set(self, pointer_var_id, pointer);
+
     return self;
 }
 
@@ -396,7 +310,9 @@ static VALUE
 struct_get_pointer(VALUE self)
 {
     Struct* s;
+
     Data_Get_Struct(self, Struct, s);
+
     return s->rbPointer;
 }
 
@@ -406,11 +322,13 @@ struct_set_layout(VALUE self, VALUE layout)
     Struct* s;
     Data_Get_Struct(self, Struct, s);
 
-    if (!rb_obj_is_kind_of(layout, classStructLayout)) {
+    if (!rb_obj_is_kind_of(layout, StructLayoutClass)) {
         rb_raise(rb_eArgError, "Invalid Struct layout");
     }
+
     Data_Get_Struct(layout, StructLayout, s->layout);
-    rb_ivar_set(self, layoutID, layout);
+    rb_ivar_set(self, layout_var_id, layout);
+
     return self;
 }
 
@@ -418,6 +336,7 @@ static VALUE
 struct_get_layout(VALUE self)
 {
     Struct* s;
+
     Data_Get_Struct(self, Struct, s);
 
     return s->rbLayout;
@@ -427,16 +346,22 @@ static VALUE
 struct_layout_allocate(VALUE klass)
 {
     StructLayout* layout;
-    return Data_Make_Struct(klass, StructLayout, struct_layout_mark, struct_layout_free, layout);
+    VALUE obj;
+    
+    obj = Data_Make_Struct(klass, StructLayout, struct_layout_mark, -1, layout);
+    layout->rbFields = Qnil;
+
+    return obj;
 }
 
 static VALUE
 struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
 {
     StructLayout* layout;
+    int i;
 
     Data_Get_Struct(self, StructLayout, layout);
-    layout->rbFields = fields;
+    layout->rbFields = rb_hash_new();
     layout->size = NUM2INT(size);
     layout->align = NUM2INT(align);
     
@@ -445,6 +370,14 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
     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");
+        }
+        rb_hash_aset(layout->rbFields, name, field);
+    }
     return self;
 }
 
@@ -454,6 +387,7 @@ struct_layout_aref(VALUE self, VALUE field)
     StructLayout* layout;
 
     Data_Get_Struct(self, StructLayout, layout);
+
     return rb_hash_aref(layout->rbFields, field);
 }
 
@@ -461,70 +395,71 @@ struct_layout_aref(VALUE self, VALUE field)
 static void
 struct_layout_mark(StructLayout *layout)
 {
-    if (layout->rbFields != Qnil) {
-        rb_gc_mark(layout->rbFields);
-    }
-}
-
-static void
-struct_layout_free(StructLayout *layout)
-{
-    xfree(layout);
+    rb_gc_mark(layout->rbFields);
 }
 
 void
-rb_FFI_Struct_Init()
+rbffi_Struct_Init(VALUE moduleFFI)
 {
-    VALUE moduleFFI = rb_define_module("FFI");
-    VALUE klass;
-    rb_FFI_Struct_class = classStruct = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
-    classStructLayout = rb_define_class_under(moduleFFI, "StructLayout", rb_cObject);
-    classStructLayoutBuilder = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
-    classStructField = rb_define_class_under(classStructLayoutBuilder, "Field", rb_cObject);
-
-    rb_define_alloc_func(classStruct, struct_allocate);
-    rb_define_method(classStruct, "initialize", struct_initialize, -1);
-    
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "alloc_inout", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_in", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_out", "new");
-    rb_define_alias(rb_singleton_class(classStruct), "new_inout", "new");
+    VALUE klass, StructClass;
+    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);
 
-    rb_define_method(classStruct, "pointer", struct_get_pointer, 0);
-    rb_define_private_method(classStruct, "pointer=", struct_set_pointer, 1);
+    StructLayoutBuilderClass = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
+    rb_global_variable(&StructLayoutBuilderClass);
 
-    rb_define_method(classStruct, "layout", struct_get_layout, 0);
-    rb_define_private_method(classStruct, "layout=", struct_set_layout, 1);
+    StructFieldClass = rb_define_class_under(StructLayoutBuilderClass, "Field", rb_cObject);
+    rb_global_variable(&StructFieldClass);
 
-    rb_define_method(classStruct, "[]", struct_get_field, 1);
-    rb_define_method(classStruct, "[]=", struct_put_field, 2);
+    rb_define_alloc_func(StructClass, struct_allocate);
+    rb_define_method(StructClass, "initialize", struct_initialize, -1);
     
-    rb_define_alloc_func(classStructField, struct_field_allocate);
-    rb_define_method(classStructField, "initialize", struct_field_initialize, -1);
-    rb_define_method(classStructField, "offset", struct_field_offset, 0);
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_in", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_out", "new");
+    rb_define_alias(rb_singleton_class(StructClass), "new_inout", "new");
+
+    rb_define_method(StructClass, "pointer", struct_get_pointer, 0);
+    rb_define_private_method(StructClass, "pointer=", struct_set_pointer, 1);
+
+    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_alloc_func(classStructLayout, struct_layout_allocate);
-    rb_define_method(classStructLayout, "initialize", struct_layout_initialize, 4);
-    rb_define_method(classStructLayout, "[]", struct_layout_aref, 1);
-
-    pointerID = rb_intern("@pointer");
-    layoutID = rb_intern("@layout");
-    getID = rb_intern("get");
-    putID = rb_intern("put");
+    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(classStructLayoutBuilder, #name, classStructField); \
-    rb_define_method(klass, "put", struct_field_put_##typeName, 2); \
-    rb_define_method(klass, "get", struct_field_get_##typeName, 1); \
-    rb_define_const(klass, "ALIGN", INT2NUM((sizeof(s) - sizeof(T)) * 8)); \
-    rb_define_const(klass, "SIZE", INT2NUM(sizeof(T)* 8)); \
-    rb_define_const(klass, "TYPE", INT2NUM(nativeType)); \
+        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);