ffi 0.6.0 → 1.0.0

data/ext/ffi_c/Struct.c

@@ -45,16 +45,6 @@
 #include "StructByValue.h"
 #include "ArrayType.h"
 
-#define FFI_ALIGN(v, a)  (((((size_t) (v))-1) | ((a)-1))+1)
-
-typedef struct StructLayoutBuilder {
-    VALUE rbFieldNames;
-    VALUE rbFieldMap;
-    unsigned int size;
-    unsigned int alignment;
-    bool isUnion;
-} StructLayoutBuilder;
-
 typedef struct InlineArray_ {
     VALUE rbMemory;
     VALUE rbField;
@@ -69,14 +59,11 @@ typedef struct 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);
-
 VALUE rbffi_StructClass = Qnil;
-static VALUE StructLayoutBuilderClass = Qnil;
 
 VALUE rbffi_StructInlineArrayClass = Qnil;
 VALUE rbffi_StructLayoutCharArrayClass = Qnil;
@@ -116,10 +103,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)) {
@@ -132,13 +117,74 @@ 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));
+    }
+
+    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 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
 struct_mark(Struct *s)
 {
@@ -151,8 +197,9 @@ struct_field(Struct* s, VALUE fieldName)
 {
     StructLayout* layout = s->layout;
     VALUE rbField;
-    if (layout == NULL) {
-        rb_raise(rb_eRuntimeError, "layout not set for Struct");
+
+    if (likely(SYMBOL_P(fieldName) && st_lookup(layout->fieldSymbolTable, fieldName, (st_data_t *) &rbField))) {
+        return rbField;
     }
 
     rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
@@ -170,8 +217,9 @@ struct_aref(VALUE self, VALUE fieldName)
     Struct* s;
     VALUE rbField;
     StructField* f;
-    
-    Data_Get_Struct(self, Struct, s);
+
+    s = struct_validate(self);
+
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
 
@@ -196,7 +244,8 @@ struct_aset(VALUE self, VALUE fieldName, VALUE value)
     StructField* f;
 
 
-    Data_Get_Struct(self, Struct, s);
+    s = struct_validate(self);
+
     rbField = struct_field(s, fieldName);
     f = (StructField *) DATA_PTR(rbField);
     if (f->put != NULL) {
@@ -221,12 +270,25 @@ 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);
@@ -251,7 +313,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);
@@ -270,293 +334,35 @@ struct_get_layout(VALUE self)
     return s->rbLayout;
 }
 
-static VALUE
-struct_layout_builder_allocate(VALUE klass)
-{
-    StructLayoutBuilder* builder;
-    VALUE obj;
-
-    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_builder_initialize(VALUE self)
-{
-    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)
+struct_null_p(VALUE self)
 {
-    StructLayoutBuilder* builder;
-    unsigned int align = NUM2UINT(rbAlign);
-
-    Data_Get_Struct(self, StructLayoutBuilder, builder);
-    builder->size = MAX(align, builder->alignment);
-
-    return UINT2NUM(builder->alignment);
-}
-
-static VALUE
-struct_layout_builder_set_union(VALUE self, VALUE rbUnion)
-{
-    StructLayoutBuilder* builder;
-
+    Struct* s;
 
-    Data_Get_Struct(self, StructLayoutBuilder, builder);
-    builder->isUnion = RTEST(rbUnion);
+    Data_Get_Struct(self, Struct, s);
 
-    return rbUnion;
+    return s->pointer->address == NULL ? Qtrue : Qfalse;
 }
 
 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)
+struct_order(int argc, VALUE* argv, VALUE self)
 {
-    rb_ary_push(builder->rbFieldNames, rbName);
-    rb_hash_aset(builder->rbFieldMap, rbName, rbField);
-
-    builder->alignment = MAX(builder->alignment, alignment);
+    Struct* s;
 
-    if (builder->isUnion) {
-        builder->size = MAX(builder->size, size);
-    } else {
-        builder->size = MAX(builder->size, offset + size);
-    }
-}
+    Data_Get_Struct(self, Struct, s);
+    if (argc == 0) {
+        return rb_funcall(s->rbPointer, rb_intern("order"), 0);
 
-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);
-    
-    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;
+        VALUE retval = rb_obj_dup(self);
+        VALUE rbPointer = rb_funcall2(s->rbPointer, rb_intern("order"), argc, argv);
+        struct_set_pointer(retval, rbPointer);
         
-        if (rb_obj_is_kind_of(rbType, rbffi_FunctionTypeClass)) {
-
-            rbFieldClass = rbffi_StructLayoutFunctionFieldClass;
-
-        } else if (rb_obj_is_kind_of(rbType, rbffi_StructByValueClass)) {
-            
-            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;
+        return retval;
     }
-
-    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;
-    VALUE rbFieldClass = 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;
-    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;
-}
-
-static VALUE
-struct_layout_builder_add_array(int argc, VALUE* argv, VALUE self)
-{
-    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);
-
-    offset = calculate_offset(builder, alignment, rbOffset);
-
-    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)
@@ -773,10 +579,6 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
     rb_global_variable(&rbffi_StructClass);
 
-
-    StructLayoutBuilderClass = rb_define_class_under(moduleFFI, "StructLayoutBuilder", rb_cObject);
-    rb_global_variable(&StructLayoutBuilderClass);
-
     rbffi_StructInlineArrayClass = rb_define_class_under(rbffi_StructClass, "InlineArray", rb_cObject);
     rb_global_variable(&rbffi_StructInlineArrayClass);
 
@@ -787,6 +589,7 @@ rbffi_Struct_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(StructClass, struct_allocate);
     rb_define_method(StructClass, "initialize", struct_initialize, -1);
+    rb_define_method(StructClass, "order", struct_order, -1);
     
     rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new");
     rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new");
@@ -803,22 +606,7 @@ rbffi_Struct_Init(VALUE moduleFFI)
 
     rb_define_method(StructClass, "[]", struct_aref, 1);
     rb_define_method(StructClass, "[]=", struct_aset, 2);
-    
-    
-
-    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_define_method(StructClass, "null?", struct_null_p, 0);
 
     rb_include_module(rbffi_StructInlineArrayClass, rb_mEnumerable);
     rb_define_alloc_func(rbffi_StructInlineArrayClass, inline_array_allocate);

data/ext/ffi_c/Struct.h

@@ -32,6 +32,11 @@
 
 #include "AbstractMemory.h"
 #include "Type.h"
+#ifdef RUBY_1_9
+#include <ruby/st.h>
+#else
+#include <st.h>
+#endif
 
 #ifdef	__cplusplus
 extern "C" {
@@ -63,6 +68,7 @@ extern "C" {
         int size;
         int align;
         ffi_type** ffiTypes;
+        struct st_table* fieldSymbolTable;
         VALUE rbFieldNames;
         VALUE rbFieldMap;
         VALUE rbFields;

data/ext/ffi_c/StructByReference.c

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2010, 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.
+ */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <ruby.h>
+
+#include <ffi.h>
+#include "rbffi.h"
+#include "compat.h"
+
+#include "Pointer.h"
+#include "Struct.h"
+#include "StructByReference.h"
+
+
+#define FFI_ALIGN(v, a)  (((((size_t) (v))-1) | ((a)-1))+1)
+
+static VALUE sbr_allocate(VALUE);
+static VALUE sbr_initialize(VALUE, VALUE);
+static void sbr_mark(StructByReference *);
+
+VALUE rbffi_StructByReferenceClass = Qnil;
+
+static VALUE
+sbr_allocate(VALUE klass)
+{
+    StructByReference* sbr;
+
+    VALUE obj = Data_Make_Struct(klass, StructByReference, sbr_mark, -1, sbr);
+
+    sbr->rbStructClass = Qnil;
+
+    return obj;
+}
+
+static VALUE
+sbr_initialize(VALUE self, VALUE rbStructClass)
+{
+    StructByReference* sbr = NULL;
+    
+    if (!rb_class_inherited_p(rbStructClass, rbffi_StructClass)) {
+        rb_raise(rb_eTypeError, "wrong type (expected subclass of FFI::Struct)");
+    }
+
+    Data_Get_Struct(self, StructByReference, sbr);
+    sbr->rbStructClass = rbStructClass;
+    
+    return self;
+}
+
+static void
+sbr_mark(StructByReference *sbr)
+{
+    rb_gc_mark(sbr->rbStructClass);
+}
+
+
+static VALUE
+sbr_struct_class(VALUE self)
+{
+    StructByReference* sbr;
+
+    Data_Get_Struct(self, StructByReference, sbr);
+
+    return sbr->rbStructClass;
+}
+
+static VALUE
+sbr_native_type(VALUE self)
+{
+    return rb_const_get(rbffi_TypeClass, rb_intern("POINTER"));
+}
+
+static VALUE
+sbr_to_native(VALUE self, VALUE value, VALUE ctx)
+{
+    StructByReference* sbr;
+    Struct* s;
+
+    if (unlikely(value == Qnil)) {
+        return rbffi_NullPointerSingleton;
+    }
+
+    Data_Get_Struct(self, StructByReference, sbr);
+    if (!rb_obj_is_kind_of(value, sbr->rbStructClass)) {
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+                rb_obj_classname(value),
+                RSTRING_PTR(rb_class_name(sbr->rbStructClass)));
+    }
+
+    Data_Get_Struct(value, Struct, s);
+
+    return s->rbPointer;
+}
+
+static VALUE
+sbr_from_native(VALUE self, VALUE value, VALUE ctx)
+{
+    StructByReference* sbr;
+
+    Data_Get_Struct(self, StructByReference, sbr);
+
+    return rb_class_new_instance(1, &value, sbr->rbStructClass);
+}
+
+
+void
+rbffi_StructByReference_Init(VALUE moduleFFI)
+{
+    rbffi_StructByReferenceClass = rb_define_class_under(moduleFFI, "StructByReference", rb_cObject);
+    rb_global_variable(&rbffi_StructByReferenceClass);
+    rb_include_module(rbffi_StructByReferenceClass, rb_const_get(moduleFFI, rb_intern("DataConverter")));
+    
+    rb_define_alloc_func(rbffi_StructByReferenceClass, sbr_allocate);
+    rb_define_method(rbffi_StructByReferenceClass, "initialize", sbr_initialize, 1);
+    rb_define_method(rbffi_StructByReferenceClass, "struct_class", sbr_struct_class, 0);
+    rb_define_method(rbffi_StructByReferenceClass, "native_type", sbr_native_type, 0);
+    rb_define_method(rbffi_StructByReferenceClass, "to_native", sbr_to_native, 2);
+    rb_define_method(rbffi_StructByReferenceClass, "from_native", sbr_from_native, 2);
+}
+