ffi 1.1.5 → 1.15.5

data/ext/ffi_c/Struct.c

@@ -1,36 +1,39 @@
 /*
  * Copyright (c) 2008, 2009, Wayne Meissner
- * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ * Copyright (C) 2009 Luc Heinrich <luc@honk-honk.com>
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * 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.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * 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 <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <sys/types.h>
-
-#include "Function.h"
 #ifndef _MSC_VER
-#include <sys/param.h>
+# include <sys/param.h>
+#endif
 #include <stdint.h>
 #include <stdbool.h>
-#else
-typedef int bool;
-#define true 1
-#define false 0
-#endif
 #include <ruby.h>
 #include "rbffi.h"
 #include "compat.h"
@@ -39,10 +42,11 @@ typedef int bool;
 #include "MemoryPointer.h"
 #include "Function.h"
 #include "Types.h"
-#include "Struct.h"
+#include "Function.h"
 #include "StructByValue.h"
 #include "ArrayType.h"
 #include "MappedType.h"
+#include "Struct.h"
 
 typedef struct InlineArray_ {
     VALUE rbMemory;
@@ -83,13 +87,20 @@ struct_allocate(VALUE klass)
 {
     Struct* s;
     VALUE obj = Data_Make_Struct(klass, Struct, struct_mark, struct_free, s);
-    
+
     s->rbPointer = Qnil;
     s->rbLayout = Qnil;
 
     return obj;
 }
 
+/*
+ * call-seq: initialize
+ * @overload initialize(pointer, *args)
+ *  @param [AbstractMemory] pointer
+ *  @param [Array] args
+ * @return [self]
+ */
 static VALUE
 struct_initialize(int argc, VALUE* argv, VALUE self)
 {
@@ -98,7 +109,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     int nargs;
 
     Data_Get_Struct(self, Struct, s);
-    
+
     nargs = rb_scan_args(argc, argv, "01*", &rbPointer, &rest);
 
     /* Call up into ruby code to adjust the layout */
@@ -113,7 +124,7 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     }
 
     Data_Get_Struct(s->rbLayout, StructLayout, s->layout);
-    
+
     if (rbPointer != Qnil) {
         s->pointer = MEMORY(rbPointer);
         s->rbPointer = rbPointer;
@@ -124,21 +135,26 @@ struct_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+/*
+ * call-seq: initialize_copy(other)
+ * @return [nil]
+ * DO NOT CALL THIS METHOD
+ */
 static VALUE
 struct_initialize_copy(VALUE self, VALUE other)
 {
     Struct* src;
     Struct* dst;
-    
+
     Data_Get_Struct(self, Struct, dst);
     Data_Get_Struct(other, Struct, src);
     if (dst == src) {
         return self;
     }
-    
+
     dst->rbLayout = src->rbLayout;
     dst->layout = src->layout;
-    
+
     /*
      * A new MemoryPointer instance is allocated here instead of just calling
      * #dup on rbPointer, since the Pointer may not know its length, or may
@@ -157,7 +173,7 @@ struct_initialize_copy(VALUE self, VALUE other)
         dst->rbReferences = ALLOC_N(VALUE, dst->layout->referenceFieldCount);
         memcpy(dst->rbReferences, src->rbReferences, dst->layout->referenceFieldCount * sizeof(VALUE));
     }
-        
+
     return self;
 }
 
@@ -165,11 +181,11 @@ static VALUE
 struct_class_layout(VALUE klass)
 {
     VALUE layout;
-    if (!rb_cvar_defined(klass, id_layout_ivar)) {
+    if (!rb_ivar_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);
+    layout = rb_ivar_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));
     }
@@ -260,70 +276,79 @@ store_reference_value(StructField* f, Struct* s, VALUE value)
 }
 
 
-static VALUE
+static StructField *
 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);
-        rb_raise(rb_eArgError, "No such field '%s'", StringValuePtr(str));
+    struct field_cache_entry *p_ce = FIELD_CACHE_LOOKUP(layout, fieldName);
+
+    /* Do a hash lookup only if cache entry is empty or fieldName is unexpected? */
+    if (unlikely(!SYMBOL_P(fieldName) || !p_ce->fieldName || p_ce->fieldName != fieldName)) {
+        VALUE rbField = rb_hash_aref(layout->rbFieldMap, fieldName);
+        if (unlikely(NIL_P(rbField))) {
+            VALUE str = rb_funcall2(fieldName, id_to_s, 0, NULL);
+            rb_raise(rb_eArgError, "No such field '%s'", StringValueCStr(str));
+        }
+        /* Write the retrieved coder to the cache */
+        p_ce->fieldName = fieldName;
+        p_ce->field = (StructField *) DATA_PTR(rbField);
     }
 
-    return rbField;
+    return p_ce->field;
 }
 
+/*
+ * call-seq: struct[field_name]
+ * @param field_name field to access
+ * Acces to a Struct field.
+ */
 static VALUE
 struct_aref(VALUE self, VALUE fieldName)
 {
     Struct* s;
-    VALUE rbField;
     StructField* f;
 
     s = struct_validate(self);
 
-    rbField = struct_field(s, fieldName);
-    f = (StructField *) DATA_PTR(rbField);
-
+    f = struct_field(s, fieldName);
     if (f->get != NULL) {
         return (*f->get)(f, s);
-    
+
     } else if (f->memoryOp != NULL) {
         return (*f->memoryOp->get)(s->pointer, f->offset);
 
     } else {
-    
+        VALUE rbField = rb_hash_aref(s->layout->rbFieldMap, fieldName);
         /* call up to the ruby code to fetch the value */
         return rb_funcall2(rbField, id_get, 1, &s->rbPointer);
     }
 }
 
+/*
+ * call-seq: []=(field_name, value)
+ * @param field_name field to access
+ * @param value value to set to +field_name+
+ * @return [value]
+ * Set a field in Struct.
+ */
 static VALUE
 struct_aset(VALUE self, VALUE fieldName, VALUE value)
 {
     Struct* s;
-    VALUE rbField;
     StructField* f;
 
-
     s = struct_validate(self);
 
-    rbField = struct_field(s, fieldName);
-    f = (StructField *) DATA_PTR(rbField);
+    f = struct_field(s, fieldName);
     if (f->put != NULL) {
         (*f->put)(f, s, value);
 
     } else if (f->memoryOp != NULL) {
 
         (*f->memoryOp->put)(s->pointer, f->offset, value);
-    
+
     } else {
+        VALUE rbField = rb_hash_aref(s->layout->rbFieldMap, fieldName);
         /* call up to the ruby code to set the value */
         VALUE argv[2];
         argv[0] = s->rbPointer;
@@ -334,10 +359,16 @@ struct_aset(VALUE self, VALUE fieldName, VALUE value)
     if (f->referenceRequired) {
         store_reference_value(f, s, value);
     }
-    
+
     return value;
 }
 
+/*
+ * call-seq: pointer= pointer
+ * @param [AbstractMemory] pointer
+ * @return [self]
+ * Make Struct point to +pointer+.
+ */
 static VALUE
 struct_set_pointer(VALUE self, VALUE pointer)
 {
@@ -351,7 +382,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
         return Qnil;
     }
 
-    
+
     Data_Get_Struct(self, Struct, s);
     Data_Get_Struct(pointer, AbstractMemory, memory);
     layout = struct_layout(self);
@@ -360,7 +391,7 @@ struct_set_pointer(VALUE self, VALUE pointer)
         rb_raise(rb_eArgError, "memory of %ld bytes too small for struct %s (expected at least %ld)",
                 memory->size, rb_obj_classname(self), (long) layout->base.ffiType->size);
     }
-    
+
     s->pointer = MEMORY(pointer);
     s->rbPointer = pointer;
     rb_ivar_set(self, id_pointer_ivar, pointer);
@@ -368,6 +399,11 @@ struct_set_pointer(VALUE self, VALUE pointer)
     return self;
 }
 
+/*
+ * call-seq: pointer
+ * @return [AbstractMemory]
+ * Get pointer to Struct contents.
+ */
 static VALUE
 struct_get_pointer(VALUE self)
 {
@@ -378,6 +414,12 @@ struct_get_pointer(VALUE self)
     return s->rbPointer;
 }
 
+/*
+ * call-seq: layout= layout
+ * @param [StructLayout] layout
+ * @return [self]
+ * Set the Struct's layout.
+ */
 static VALUE
 struct_set_layout(VALUE self, VALUE layout)
 {
@@ -396,6 +438,11 @@ struct_set_layout(VALUE self, VALUE layout)
     return self;
 }
 
+/*
+ * call-seq: layout
+ * @return [StructLayout]
+ * Get the Struct's layout.
+ */
 static VALUE
 struct_get_layout(VALUE self)
 {
@@ -406,7 +453,11 @@ struct_get_layout(VALUE self)
     return s->rbLayout;
 }
 
-
+/*
+ * call-seq: null?
+ * @return [Boolean]
+ * Test if Struct's pointer is NULL
+ */
 static VALUE
 struct_null_p(VALUE self)
 {
@@ -417,6 +468,9 @@ struct_null_p(VALUE self)
     return s->pointer->address == NULL ? Qtrue : Qfalse;
 }
 
+/*
+ * (see Pointer#order)
+ */
 static VALUE
 struct_order(int argc, VALUE* argv, VALUE self)
 {
@@ -430,12 +484,11 @@ struct_order(int argc, VALUE* argv, VALUE self)
         VALUE retval = rb_obj_dup(self);
         VALUE rbPointer = rb_funcall2(s->rbPointer, rb_intern("order"), argc, argv);
         struct_set_pointer(retval, rbPointer);
-        
+
         return retval;
     }
 }
 
-
 static VALUE
 inline_array_allocate(VALUE klass)
 {
@@ -456,11 +509,18 @@ inline_array_mark(InlineArray* array)
     rb_gc_mark(array->rbMemory);
 }
 
+/*
+ * Document-method: FFI::Struct::InlineArray#initialize
+ * call-seq: initialize(memory, field)
+ * @param [AbstractMemory] memory
+ * @param [StructField] field
+ * @return [self]
+ */
 static VALUE
 inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
 {
     InlineArray* array;
-    
+
     Data_Get_Struct(self, InlineArray, array);
     array->rbMemory = rbMemory;
     array->rbField = rbField;
@@ -469,17 +529,22 @@ inline_array_initialize(VALUE self, VALUE rbMemory, VALUE rbField)
     Data_Get_Struct(rbField, StructField, array->field);
     Data_Get_Struct(array->field->rbType, ArrayType, array->arrayType);
     Data_Get_Struct(array->arrayType->rbComponentType, Type, array->componentType);
-    
+
     array->op = get_memory_op(array->componentType);
     if (array->op == NULL && array->componentType->nativeType == NATIVE_MAPPED) {
         array->op = get_memory_op(((MappedType *) array->componentType)->type);
     }
-    
+
     array->length = array->arrayType->length;
 
     return self;
 }
 
+/*
+ * call-seq: size
+ * @return [Numeric]
+ * Get size
+ */
 static VALUE
 inline_array_size(VALUE self)
 {
@@ -493,13 +558,18 @@ inline_array_size(VALUE self)
 static int
 inline_array_offset(InlineArray* array, int index)
 {
-    if (index < 0 || index >= array->length) {
+    if (index < 0 || (index >= array->length && array->length > 0)) {
         rb_raise(rb_eIndexError, "index %d out of bounds", index);
     }
 
     return (int) array->field->offset + (index * (int) array->componentType->ffiType->size);
 }
 
+/*
+ * call-seq: [](index)
+ * @param [Numeric] index
+ * @return [Type, Struct]
+ */
 static VALUE
 inline_array_aref(VALUE self, VALUE rbIndex)
 {
@@ -508,15 +578,15 @@ inline_array_aref(VALUE self, VALUE rbIndex)
     Data_Get_Struct(self, InlineArray, array);
 
     if (array->op != NULL) {
-        VALUE rbNativeValue = array->op->get(array->memory, 
+        VALUE rbNativeValue = array->op->get(array->memory,
                 inline_array_offset(array, NUM2INT(rbIndex)));
         if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
-            return rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+            return rb_funcall(((MappedType *) array->componentType)->rbConverter,
                     rb_intern("from_native"), 2, rbNativeValue, Qnil);
         } else {
-            return rbNativeValue; 
+            return rbNativeValue;
         }
-        
+
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         VALUE rbOffset = INT2NUM(inline_array_offset(array, NUM2INT(rbIndex)));
         VALUE rbLength = INT2NUM(array->componentType->ffiType->size);
@@ -530,6 +600,12 @@ inline_array_aref(VALUE self, VALUE rbIndex)
     }
 }
 
+/*
+ * call-seq: []=(index, value)
+ * @param [Numeric] index
+ * @param [Type, Struct]
+ * @return [value]
+ */
 static VALUE
 inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
 {
@@ -539,12 +615,12 @@ inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
 
     if (array->op != NULL) {
         if (unlikely(array->componentType->nativeType == NATIVE_MAPPED)) {
-            rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter, 
+            rbValue = rb_funcall(((MappedType *) array->componentType)->rbConverter,
                     rb_intern("to_native"), 2, rbValue, Qnil);
         }
         array->op->put(array->memory, inline_array_offset(array, NUM2INT(rbIndex)),
             rbValue);
-        
+
     } else if (array->componentType->nativeType == NATIVE_STRUCT) {
         int offset = inline_array_offset(array, NUM2INT(rbIndex));
         Struct* s;
@@ -574,15 +650,19 @@ inline_array_aset(VALUE self, VALUE rbIndex, VALUE rbValue)
     return rbValue;
 }
 
+/*
+ * call-seq: each
+ * Yield block for each element of +self+.
+ */
 static VALUE
 inline_array_each(VALUE self)
 {
     InlineArray* array;
-    
+
     int i;
 
     Data_Get_Struct(self, InlineArray, array);
-    
+
     for (i = 0; i < array->length; ++i) {
         rb_yield(inline_array_aref(self, INT2FIX(i)));
     }
@@ -590,6 +670,11 @@ inline_array_each(VALUE self)
     return self;
 }
 
+/*
+ * call-seq: to_a
+ * @return [Array]
+ * Convert +self+ to an array.
+ */
 static VALUE
 inline_array_to_a(VALUE self)
 {
@@ -600,7 +685,7 @@ inline_array_to_a(VALUE self)
     Data_Get_Struct(self, InlineArray, array);
     obj = rb_ary_new2(array->length);
 
-    
+
     for (i = 0; i < array->length; ++i) {
         rb_ary_push(obj, inline_array_aref(self, INT2FIX(i)));
     }
@@ -608,6 +693,12 @@ inline_array_to_a(VALUE self)
     return obj;
 }
 
+/*
+ * Document-method: FFI::StructLayout::CharArray#to_s
+ * call-seq: to_s
+ * @return [String]
+ * Convert +self+ to a string.
+ */
 static VALUE
 inline_array_to_s(VALUE self)
 {
@@ -615,7 +706,7 @@ inline_array_to_s(VALUE self)
     VALUE argv[2];
 
     Data_Get_Struct(self, InlineArray, array);
- 
+
     if (array->componentType->nativeType != NATIVE_INT8 && array->componentType->nativeType != NATIVE_UINT8) {
         VALUE dummy = Qnil;
         return rb_call_super(0, &dummy);
@@ -627,12 +718,16 @@ inline_array_to_s(VALUE self)
     return rb_funcall2(array->rbMemory, rb_intern("get_string"), 2, argv);
 }
 
-
+/*
+ * call-seq: to_ptr
+ * @return [AbstractMemory]
+ * Get pointer to +self+ content.
+ */
 static VALUE
 inline_array_to_ptr(VALUE self)
 {
     InlineArray* array;
-    
+
     Data_Get_Struct(self, InlineArray, array);
 
     return rb_funcall(array->rbMemory, rb_intern("slice"), 2,
@@ -647,14 +742,37 @@ rbffi_Struct_Init(VALUE moduleFFI)
 
     rbffi_StructLayout_Init(moduleFFI);
 
-    rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
+    /*
+     * Document-class: FFI::Struct
+     *
+     * A FFI::Struct means to mirror a C struct.
+     *
+     * A Struct is defined as:
+     *  class MyStruct < FFI::Struct
+     *    layout :value1, :int,
+     *           :value2, :double
+     *  end
+     * and is used as:
+     *  my_struct = MyStruct.new
+     *  my_struct[:value1] = 12
+     *
+     * For more information, see http://github.com/ffi/ffi/wiki/Structs
+     */
+    rbffi_StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject);
+    StructClass = rbffi_StructClass; // put on a line alone to help RDoc
     rb_global_variable(&rbffi_StructClass);
 
+    /*
+     * Document-class: FFI::Struct::InlineArray
+     */
     rbffi_StructInlineArrayClass = rb_define_class_under(rbffi_StructClass, "InlineArray", rb_cObject);
     rb_global_variable(&rbffi_StructInlineArrayClass);
 
-    rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass,
-        "CharArray", rbffi_StructInlineArrayClass);
+    /*
+     * Document-class: FFI::StructLayout::CharArray < FFI::Struct::InlineArray
+     */
+    rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass, "CharArray",
+                                                             rbffi_StructInlineArrayClass);
     rb_global_variable(&rbffi_StructLayoutCharArrayClass);
 
 
@@ -662,7 +780,7 @@ rbffi_Struct_Init(VALUE moduleFFI)
     rb_define_method(StructClass, "initialize", struct_initialize, -1);
     rb_define_method(StructClass, "initialize_copy", struct_initialize_copy, 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");
     rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new");

data/ext/ffi_c/Struct.h

@@ -2,21 +2,30 @@
  * Copyright (c) 2008, 2009, Wayne Meissner
  * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
  *
+ * Copyright (c) 2008-2013, Ruby FFI project contributors
  * All rights reserved.
  *
- * This file is part of ruby-ffi.
+ * 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.
+ *     * Neither the name of the Ruby FFI project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
  *
- * This code is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- * version 3 for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+ * 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 <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef RBFFI_STRUCT_H
@@ -25,11 +34,7 @@
 #include "extconf.h"
 #include "AbstractMemory.h"
 #include "Type.h"
-#ifdef RUBY_1_9
 #include <ruby/st.h>
-#else
-#include <st.h>
-#endif
 
 #ifdef	__cplusplus
 extern "C" {
@@ -64,11 +69,21 @@ extern "C" {
         int size;
         int align;
         ffi_type** ffiTypes;
-        struct st_table* fieldSymbolTable;
+
+        /*
+        * We use the fieldName's minor 8 Bits as index to a 256 entry cache.
+        * This avoids full ruby hash lookups for repeated lookups.
+        */
+        #define FIELD_CACHE_LOOKUP(this, sym) ( &(this)->cache_row[((sym) >> 8) & 0xff] )
+
+        struct field_cache_entry {
+          VALUE fieldName;
+          StructField *field;
+        } cache_row[0x100];
 
         /** The number of reference tracking fields in this struct */
         int referenceFieldCount;
-        
+
         VALUE rbFieldNames;
         VALUE rbFieldMap;
         VALUE rbFields;