ffi 0.3.0 → 0.3.1

data/ext/ffi_c/Callback.c

@@ -15,8 +15,7 @@
 #include "extconf.h"
 
 
-static void CallbackInfo_mark(CallbackInfo *);
-static void CallbackInfo_free(CallbackInfo *);
+static void cbinfo_free(CallbackInfo *);
 
 #if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
 static void* ffi_closure_alloc(size_t size, void** code);
@@ -33,18 +32,29 @@ static ID callID = Qnil, cbTableID = Qnil;
 VALUE rb_FFI_CallbackInfo_class = Qnil;
 
 static VALUE
-CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
+cbinfo_allocate(VALUE klass)
+{
+    CallbackInfo* cbInfo;
+    return Data_Make_Struct(klass, CallbackInfo, NULL, cbinfo_free, cbInfo);
+}
+
+static VALUE
+cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
 {
     CallbackInfo *cbInfo;
-    VALUE retval;
-    int paramCount = RARRAY_LEN(rbParamTypes);
+    int paramCount;
     ffi_status status;
     int i;
 
-    retval = Data_Make_Struct(klass, CallbackInfo, CallbackInfo_mark, CallbackInfo_free, cbInfo);
+    Check_Type(rbParamTypes, T_ARRAY);
+    paramCount = RARRAY_LEN(rbParamTypes);
+
+    Data_Get_Struct(self, CallbackInfo, cbInfo);
     cbInfo->parameterCount = paramCount;
     cbInfo->parameterTypes = xcalloc(paramCount, sizeof(NativeType));
     cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
+    cbInfo->returnType = FIX2INT(rbReturnType);
+
     for (i = 0; i < paramCount; ++i) {
         cbInfo->parameterTypes[i] = FIX2INT(rb_ary_entry(rbParamTypes, i));
         cbInfo->ffiParameterTypes[i] = rb_FFI_NativeTypeToFFI(cbInfo->parameterTypes[i]);
@@ -52,7 +62,7 @@ CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
             rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]);
         }
     }
-    cbInfo->returnType = FIX2INT(rbReturnType);
+
     cbInfo->ffiReturnType = rb_FFI_NativeTypeToFFI(cbInfo->returnType);
     if (cbInfo->ffiReturnType == NULL) {
         rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType);
@@ -74,38 +84,28 @@ CallbackInfo_new(VALUE klass, VALUE rbReturnType, VALUE rbParamTypes)
         default:
             rb_raise(rb_eArgError, "Unknown FFI error");
     }
-    return retval;
+    return self;
 }
 
 static void
-CallbackInfo_mark(CallbackInfo* cbinfo)
+cbinfo_free(CallbackInfo* cbInfo)
 {
-}
-
-static void
-CallbackInfo_free(CallbackInfo* cbInfo)
-{
-    if (cbInfo != NULL) {
-        if (cbInfo->parameterTypes != NULL) {
-            xfree(cbInfo->parameterTypes);
-            cbInfo->parameterTypes = NULL;
-        }
-        if (cbInfo->ffiParameterTypes != NULL) {
-            xfree(cbInfo->ffiParameterTypes);
-            cbInfo->ffiParameterTypes = NULL;
-        }
-        xfree(cbInfo);
+    if (cbInfo->parameterTypes != NULL) {
+        xfree(cbInfo->parameterTypes);
+    }
+    if (cbInfo->ffiParameterTypes != NULL) {
+        xfree(cbInfo->ffiParameterTypes);
     }
+    xfree(cbInfo);
 }
 
 static void
 native_callback_free(NativeCallback* cb)
 {
-    if (cb != NULL) {
-        if (cb->ffi_closure != NULL) {
-            ffi_closure_free(cb->ffi_closure);
-        }
+    if (cb->ffi_closure != NULL) {
+        ffi_closure_free(cb->ffi_closure);
     }
+    xfree(cb);
 }
 
 static void
@@ -209,30 +209,45 @@ native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user
     }
 }
 
+static VALUE
+native_callback_allocate(VALUE klass)
+{
+    NativeCallback* closure;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->rbCallbackInfo = Qnil;
+    closure->rbProc = Qnil;
+    
+    return obj;
+}
+
 VALUE
 rb_FFI_NativeCallback_new(VALUE rbCallbackInfo, VALUE rbProc)
 {
     NativeCallback* closure = NULL;
-    CallbackInfo* cbInfo = (CallbackInfo *) DATA_PTR(rbCallbackInfo);
+    CallbackInfo* cbInfo;
+    VALUE obj;
     ffi_status status;
-    
-    closure = ALLOC(NativeCallback);
+
+    Data_Get_Struct(rbCallbackInfo, CallbackInfo, cbInfo);
+    obj = Data_Make_Struct(classNativeCallback, NativeCallback, native_callback_mark, native_callback_free, closure);
+    closure->cbInfo = cbInfo;
+    closure->rbProc = rbProc;
+    closure->rbCallbackInfo = rbCallbackInfo;
+
     closure->ffi_closure = ffi_closure_alloc(sizeof(*closure->ffi_closure), &closure->code);
     if (closure->ffi_closure == NULL) {
-        xfree(closure);
         rb_raise(rb_eNoMemError, "Failed to allocate FFI native closure");
     }
-    closure->cbInfo = cbInfo;
-    closure->rbProc = rbProc;
-    closure->rbCallbackInfo = rbCallbackInfo;
+
     status = ffi_prep_closure_loc(closure->ffi_closure, &cbInfo->ffi_cif,
             native_callback_invoke, closure, closure->code);
     if (status != FFI_OK) {
-        ffi_closure_free(closure->ffi_closure);
-        xfree(closure);
         rb_raise(rb_eArgError, "ffi_prep_closure_loc failed");
     }
-    return Data_Wrap_Struct(classNativeCallback, native_callback_mark, native_callback_free, closure);
+
+    return obj;
 }
 
 VALUE
@@ -295,9 +310,13 @@ void
 rb_FFI_Callback_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
+
     rb_FFI_CallbackInfo_class = classCallbackInfo = rb_define_class_under(moduleFFI, "CallbackInfo", rb_cObject);
-    rb_define_singleton_method(classCallbackInfo, "new", CallbackInfo_new, 2);
+    rb_define_alloc_func(classCallbackInfo, cbinfo_allocate);
+    rb_define_method(classCallbackInfo, "initialize", cbinfo_initialize, 2);
+
     classNativeCallback = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
+    rb_define_alloc_func(classNativeCallback, native_callback_allocate);
     callID = rb_intern("call");
     cbTableID = rb_intern("@__ffi_callback_table__");
 }

data/ext/ffi_c/Invoker.c

@@ -621,16 +621,20 @@ static inline VALUE
 ffi_invoke(ffi_cif* cif, void* function, NativeType returnType, void** ffiValues)
 {
     FFIStorage retval;
+    int error = 0;
+
 #ifdef USE_RAW
     ffi_raw_call(cif, FFI_FN(function), &retval, (ffi_raw *) ffiValues[0]);
 #else
     ffi_call(cif, FFI_FN(function), &retval, ffiValues);
 #endif
 #if defined(_WIN32) || defined(__WIN32__)
-    threadData->td_errno = GetLastError();
+    error = GetLastError();
 #else
-    threadData->td_errno = errno;
+    error = errno;
 #endif
+    threadData->td_errno = error;
+
     return rb_FFI_NativeValueToRuby(returnType, &retval);
 }
 static VALUE

data/ext/ffi_c/MemoryPointer.c

@@ -34,7 +34,10 @@ static VALUE
 memptr_allocate(VALUE klass)
 {
     MemoryPointer* p;
-    return Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
+    p->memory.ops = &rb_FFI_AbstractMemory_ops;
+
+    return obj;
 }
 
 static VALUE

data/ext/ffi_c/NativeLibrary.c

@@ -94,16 +94,13 @@ library_dlerror(VALUE self)
 static void
 library_free(Library* library)
 {
-    if (library != NULL) {
-        // dlclose() on MacOS tends to segfault - avoid it
+    // dlclose() on MacOS tends to segfault - avoid it
 #ifndef __APPLE__
-        if (library->handle != NULL) {
-            dl_close(library->handle);
-        }
-#endif
-        library->handle = NULL;
-        xfree(library);
+    if (library->handle != NULL) {
+        dl_close(library->handle);
     }
+#endif
+    xfree(library);
 }
 
 #if defined(_WIN32) || defined(__WIN32__)

data/ext/ffi_c/NullPointer.c

@@ -9,6 +9,8 @@
 
 static VALUE NullPointerError;
 static VALUE classNullPointer;
+static MemoryOps nullptr_ops;
+
 VALUE rb_FFI_NullPointer_class;
 VALUE rb_FFI_NullPointer_singleton;
 
@@ -21,6 +23,8 @@ rb_FFI_NullPointer_allocate(VALUE klass)
     retval = Data_Make_Struct(klass, AbstractMemory, NULL, -1, p);
     p->address = 0;
     p->size = 0;
+    p->ops = &nullptr_ops;
+
     return retval;
 }
 
@@ -30,6 +34,18 @@ nullptr_op(int argc, VALUE* argv, VALUE self)
     rb_raise(NullPointerError, "NULL Pointer access attempted");
 }
 
+static VALUE
+nullptr_op_get(AbstractMemory* ptr, long offset)
+{
+    rb_raise(NullPointerError, "NULL Pointer access attempted");
+}
+
+static void
+nullptr_op_put(AbstractMemory* ptr, long offset, VALUE value)
+{
+    rb_raise(NullPointerError, "NULL Pointer access attempted");
+}
+
 static VALUE
 nullptr_inspect(VALUE self)
 {
@@ -46,10 +62,13 @@ static VALUE
 nullptr_equals(VALUE self, VALUE other)
 {
     AbstractMemory* p2;
+
     if (!rb_obj_is_kind_of(other, rb_FFI_Pointer_class)) {
         rb_raise(rb_eArgError, "Comparing Pointer with non Pointer");
     }
+
     Data_Get_Struct(other, AbstractMemory, p2);
+
     return p2->address == 0 ? Qtrue : Qfalse;
 }
 
@@ -59,6 +78,22 @@ nullptr_address(VALUE self)
     return INT2NUM(0);
 }
 
+static MemoryOp nullptr_memory_op = { nullptr_op_get, nullptr_op_put };
+
+static MemoryOps nullptr_ops = {
+    .int8 = &nullptr_memory_op,
+    .uint8 = &nullptr_memory_op,
+    .int16 = &nullptr_memory_op,
+    .int16 = &nullptr_memory_op,
+    .int32 = &nullptr_memory_op,
+    .uint32 = &nullptr_memory_op,
+    .int64 = &nullptr_memory_op,
+    .uint64 = &nullptr_memory_op,
+    .float32 = &nullptr_memory_op,
+    .float64 = &nullptr_memory_op,
+    .pointer = &nullptr_memory_op,
+    .strptr = &nullptr_memory_op,
+};
 
 void
 rb_FFI_NullPointer_Init()

data/ext/ffi_c/Pointer.c

@@ -16,28 +16,36 @@ typedef struct Pointer {
 VALUE rb_FFI_Pointer_class;
 static VALUE classPointer = Qnil;
 static void ptr_mark(Pointer* ptr);
-static void ptr_free(Pointer* ptr);
 
 VALUE
 rb_FFI_Pointer_new(void* addr)
 {
     Pointer* p;
-    VALUE retval;
+    VALUE obj;
+
     if (addr == NULL) {
         return rb_FFI_NullPointer_singleton;
     }
-    retval = Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+
+    obj = Data_Make_Struct(classPointer, Pointer, NULL, -1, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
+    p->memory.ops = &rb_FFI_AbstractMemory_ops;
     p->parent = Qnil;
-    return retval;
+
+    return obj;
 }
 
 static VALUE
 ptr_allocate(VALUE klass)
 {
     Pointer* p;
-    return Data_Make_Struct(classPointer, Pointer, NULL, ptr_free, p);
+    VALUE obj;
+
+    obj = Data_Make_Struct(classPointer, Pointer, NULL, -1, p);
+    p->parent = Qnil;
+
+    return obj;
 }
 
 static VALUE
@@ -51,10 +59,11 @@ ptr_plus(VALUE self, VALUE offset)
     Data_Get_Struct(self, AbstractMemory, ptr);
     checkBounds(ptr, off, 1);
 
-    retval = Data_Make_Struct(classPointer, Pointer, ptr_mark, ptr_free, p);
+    retval = Data_Make_Struct(classPointer, 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 = &rb_FFI_AbstractMemory_ops;
     p->parent = self;
 
     return retval;
@@ -76,7 +85,9 @@ static VALUE
 ptr_null_p(VALUE self)
 {
     Pointer* ptr;
+
     Data_Get_Struct(self, Pointer, ptr);
+
     return ptr->memory.address == NULL ? Qtrue : Qfalse;
 }
 
@@ -84,6 +95,7 @@ static VALUE
 ptr_equals(VALUE self, VALUE other)
 {
     Pointer* ptr;
+    
     Data_Get_Struct(self, Pointer, ptr);
 
     return ptr->memory.address == POINTER(other)->address ? Qtrue : Qfalse;
@@ -93,6 +105,7 @@ static VALUE
 ptr_address(VALUE self)
 {
     Pointer* ptr;
+    
     Data_Get_Struct(self, Pointer, ptr);
 
     return ULL2NUM((uintptr_t) ptr->memory.address);
@@ -101,15 +114,7 @@ ptr_address(VALUE self)
 static void
 ptr_mark(Pointer* ptr)
 {
-    if (ptr->parent != Qnil) {
-        rb_gc_mark(ptr->parent);
-    }
-}
-
-static void
-ptr_free(Pointer* ptr)
-{
-    xfree(ptr);
+    rb_gc_mark(ptr->parent);
 }
 
 void
@@ -117,6 +122,7 @@ rb_FFI_Pointer_Init()
 {
     VALUE moduleFFI = rb_define_module("FFI");
     rb_FFI_Pointer_class = classPointer = rb_define_class_under(moduleFFI, "Pointer", rb_FFI_AbstractMemory_class);
+    rb_global_variable(&rb_FFI_Pointer_class);
 
     rb_define_alloc_func(classPointer, ptr_allocate);
     rb_define_method(classPointer, "inspect", ptr_inspect, 0);

data/ext/ffi_c/Struct.c

@@ -29,12 +29,9 @@ 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;
@@ -42,17 +39,11 @@ 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)))
-
 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
@@ -72,12 +63,14 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
     } 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")));
 #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);
@@ -227,37 +152,39 @@ 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");
-        }
+    } else if (rb_cvar_defined(klass, layoutID)) {
+        s->rbLayout = rb_cvar_get(klass, layoutID);
+    } 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, classStructLayout)) {
+        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 = rb_FFI_MemoryPointer_new(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);
         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, getID, 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, putID, 2, argv);
+    
     return self;
 }
 
@@ -389,6 +302,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
     rb_ivar_set(self, pointerID, 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;
 }
 
@@ -409,8 +325,10 @@ struct_set_layout(VALUE self, VALUE layout)
     if (!rb_obj_is_kind_of(layout, classStructLayout)) {
         rb_raise(rb_eArgError, "Invalid Struct layout");
     }
+
     Data_Get_Struct(layout, StructLayout, s->layout);
     rb_ivar_set(self, layoutID, 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, classStructField)) {
+            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,15 +395,7 @@ 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
@@ -504,7 +430,9 @@ rb_FFI_Struct_Init()
     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_method(classStructField, "put", struct_field_put, 2);
+    rb_define_method(classStructField, "get", struct_field_get, 1);
+
     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);
@@ -519,12 +447,10 @@ rb_FFI_Struct_Init()
 #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(classStructLayoutBuilder, #name, classStructField); \
+        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)); \
     } while(0)
     
     FIELD(Signed8, int8, NATIVE_INT8, char);