ffi 0.6.4 → 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,16 +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;
@@ -213,6 +198,10 @@ struct_field(Struct* s, VALUE fieldName)
     StructLayout* layout = s->layout;
     VALUE rbField;
 
+    if (likely(SYMBOL_P(fieldName) && st_lookup(layout->fieldSymbolTable, fieldName, (st_data_t *) &rbField))) {
+        return rbField;
+    }
+
     rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
     if (rbField == Qnil) {
         VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
@@ -345,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)
-{
-    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)
+struct_null_p(VALUE self)
 {
-    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;
-    }
-
-    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;
+        return retval;
     }
-    
-    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)
@@ -848,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);
 
@@ -862,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");
@@ -878,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);
+}
+