ffi 0.6.4 → 1.0.0

data/{libtest/LastErrorTest.c → ext/ffi_c/StructByReference.h}

@@ -1,17 +1,17 @@
 /*
- * Copyright (c) 2008 Wayne Meissner. All rights reserved.
- * 
+ * Copyright (c) 2009, 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.
- * Neither the name of the project nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
+ * * 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
@@ -24,18 +24,27 @@
  * 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.
  */
-#if defined(_WIN32) || defined(__WIN32__)
-# include <windows.h>
-#else
-# include <errno.h>
-#endif
 
-int setLastError(int error) {
-#if defined(_WIN32) || defined(__WIN32__)
-    SetLastError(error);
-#else
-    errno = error;
+#ifndef RBFFI_STRUCTBYREFERENCE_H
+#define	RBFFI_STRUCTBYREFERENCE_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
 #endif
-    return -1;
+
+typedef struct StructByReference_ {
+    VALUE rbStructClass;
+} StructByReference;
+
+void rbffi_StructByReference_Init(VALUE moduleFFI);
+
+extern VALUE rbffi_StructByReferenceClass;
+
+#ifdef	__cplusplus
 }
+#endif
+
+#endif	/* RBFFI_STRUCTBYREFERENCE_H */
 

data/ext/ffi_c/StructLayout.c

@@ -52,6 +52,8 @@ static void struct_layout_free(StructLayout *);
 static void struct_field_mark(StructField* );
 
 VALUE rbffi_StructLayoutFieldClass = Qnil;
+VALUE rbffi_StructLayoutNumberFieldClass = Qnil, rbffi_StructLayoutPointerFieldClass = Qnil;
+VALUE rbffi_StructLayoutStringFieldClass = Qnil;
 VALUE rbffi_StructLayoutFunctionFieldClass = Qnil, rbffi_StructLayoutArrayFieldClass = Qnil;
 
 VALUE rbffi_StructLayoutClass = Qnil;
@@ -320,6 +322,7 @@ struct_layout_allocate(VALUE klass)
     layout->rbFieldMap = Qnil;
     layout->rbFieldNames = Qnil;
     layout->rbFields = Qnil;
+    layout->fieldSymbolTable = st_init_numtable();
     layout->base.ffiType = xcalloc(1, sizeof(*layout->base.ffiType));
     layout->base.ffiType->size = 0;
     layout->base.ffiType->alignment = 0;
@@ -329,29 +332,29 @@ struct_layout_allocate(VALUE klass)
 }
 
 static VALUE
-struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size, VALUE align)
+struct_layout_initialize(VALUE self, VALUE fields, VALUE size, VALUE align)
 {
     StructLayout* layout;
     ffi_type* ltype;
     int i;
 
     Data_Get_Struct(self, StructLayout, layout);
+    layout->fieldCount = RARRAY_LEN(fields);
     layout->rbFieldMap = rb_hash_new();
-    layout->rbFieldNames = rb_ary_dup(field_names);
+    layout->rbFieldNames = rb_ary_new2(layout->fieldCount);
     layout->size = NUM2INT(size);
     layout->align = NUM2INT(align);
-    layout->fieldCount = RARRAY_LEN(field_names);
     layout->fields = xcalloc(layout->fieldCount, sizeof(StructField *));
     layout->ffiTypes = xcalloc(layout->fieldCount + 1, sizeof(ffi_type *));
     layout->rbFields = rb_ary_new2(layout->fieldCount);
     layout->base.ffiType->elements = layout->ffiTypes;
-    layout->base.ffiType->size = 0;
-    layout->base.ffiType->alignment = 1;
+    layout->base.ffiType->size = layout->size;
+    layout->base.ffiType->alignment = layout->align;
 
     ltype = layout->base.ffiType;
     for (i = 0; i < (int) layout->fieldCount; ++i) {
-        VALUE rbName = rb_ary_entry(field_names, i);
-        VALUE rbField = rb_hash_aref(fields, rbName);
+        VALUE rbField = rb_ary_entry(fields, i);
+        VALUE rbName;
         StructField* field;
         ffi_type* ftype;
 
@@ -359,9 +362,9 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
         if (!rb_obj_is_kind_of(rbField, rbffi_StructLayoutFieldClass)) {
             rb_raise(rb_eTypeError, "wrong type for field %d.", i);
         }
+        rbName = rb_funcall2(rbField, rb_intern("name"), 0, NULL);
 
-        field = layout->fields[i];
-        Data_Get_Struct(rbField, StructField, field);
+        Data_Get_Struct(rbField, StructField, field = layout->fields[i]);
 
         if (field->type == NULL || field->type->ffiType == NULL) {
             rb_raise(rb_eRuntimeError, "type of field %d not supported", i);
@@ -372,20 +375,17 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
             rb_raise(rb_eTypeError, "type of field %d has zero size", i);
         }
 
-        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         layout->ffiTypes[i] = ftype;
+        st_insert(layout->fieldSymbolTable, rbName, rbField);
+        rb_hash_aset(layout->rbFieldMap, rbName, rbField);
         rb_ary_push(layout->rbFields, rbField);
-        ltype->size = MAX(ltype->size, field->offset + ftype->size);
-        ltype->alignment = MAX(ltype->alignment, ftype->alignment);
+        rb_ary_push(layout->rbFieldNames, rbName);
     }
 
     if (ltype->size == 0) {
         rb_raise(rb_eRuntimeError, "Struct size is zero");
     }
 
-    // Include tail padding
-    ltype->size = FFI_ALIGN(ltype->size, ltype->alignment);
-
     return self;
 }
 
@@ -443,6 +443,7 @@ struct_layout_free(StructLayout *layout)
     xfree(layout->ffiTypes);
     xfree(layout->base.ffiType);
     xfree(layout->fields);
+    st_free_table(layout->fieldSymbolTable);
     xfree(layout);
 }
 
@@ -456,6 +457,15 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rbffi_StructLayoutFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Field", rb_cObject);
     rb_global_variable(&rbffi_StructLayoutFieldClass);
 
+    rbffi_StructLayoutNumberFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Number", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutNumberFieldClass);
+
+    rbffi_StructLayoutStringFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "String", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutStringFieldClass);
+
+    rbffi_StructLayoutPointerFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Pointer", rbffi_StructLayoutFieldClass);
+    rb_global_variable(&rbffi_StructLayoutPointerFieldClass);
+
     rbffi_StructLayoutFunctionFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Function", rbffi_StructLayoutFieldClass);
     rb_global_variable(&rbffi_StructLayoutFunctionFieldClass);
 
@@ -479,7 +489,7 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructLayoutArrayFieldClass, "put", array_field_put, 2);
 
     rb_define_alloc_func(rbffi_StructLayoutClass, struct_layout_allocate);
-    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 4);
+    rb_define_method(rbffi_StructLayoutClass, "initialize", struct_layout_initialize, 3);
     rb_define_method(rbffi_StructLayoutClass, "[]", struct_layout_aref, 1);
     rb_define_method(rbffi_StructLayoutClass, "fields", struct_layout_fields, 0);
     rb_define_method(rbffi_StructLayoutClass, "members", struct_layout_members, 0);

data/ext/ffi_c/Type.c

@@ -1,28 +1,19 @@
 /*
  * Copyright (c) 2009, 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 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 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.
+ * 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/>.
  */
 
 #include <sys/param.h>
@@ -42,7 +33,7 @@ typedef struct BuiltinType_ {
 
 static void builtin_type_free(BuiltinType *);
 
-VALUE rbffi_TypeClass = Qnil, rbffi_EnumTypeClass = Qnil;
+VALUE rbffi_TypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
 static VALUE typeMap = Qnil, sizeMap = Qnil;
@@ -104,41 +95,12 @@ type_alignment(VALUE self)
 static VALUE
 type_inspect(VALUE self)
 {
-    char buf[256];
     Type *type;
 
     Data_Get_Struct(self, Type, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type:%p size=%d alignment=%d>", 
-            type, (int) type->ffiType->size, (int) type->ffiType->alignment);
-
-    return rb_str_new2(buf);
-}
-
-static VALUE
-enum_allocate(VALUE klass)
-{
-    Type* type;
-    VALUE obj;
-
-    obj = Data_Make_Struct(klass, Type, NULL, -1, type);
-    type->nativeType = NATIVE_ENUM;
-    type->ffiType = &ffi_type_sint;
-
-    return obj;
-}
-
-int
-rbffi_Type_GetIntValue(VALUE type)
-{
-    Type* t;
-
-    if (!rb_obj_is_kind_of(type, rbffi_TypeClass)) {
-        rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
-    }
-
-    Data_Get_Struct(type, Type, t);
 
-    return t->nativeType;
+    return rb_sprintf("#<%s:%p size=%d alignment=%d>",
+            rb_obj_classname(self), type, (int) type->ffiType->size, (int) type->ffiType->alignment);
 }
 
 static VALUE
@@ -166,14 +128,11 @@ builtin_type_free(BuiltinType *type)
 static VALUE
 builtin_type_inspect(VALUE self)
 {
-    char buf[256];
     BuiltinType *type;
 
     Data_Get_Struct(self, BuiltinType, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type::Builtin:%s size=%d alignment=%d>",
-            type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
-
-    return rb_str_new2(buf);
+    return rb_sprintf("#<%s:%s size=%d alignment=%d>",
+            rb_obj_classname(self), type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
 }
 
 int
@@ -231,8 +190,7 @@ rbffi_Type_Find(VALUE name)
     VALUE rbType = rbffi_Type_Lookup(name);
 
     if (!RTEST(rbType)) {
-        VALUE typeName = rb_funcall2(name, rb_intern("inspect"), 0, NULL);
-        rb_raise(rb_eTypeError, "Invalid type (%s)", RSTRING_PTR(typeName));
+        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(rb_inspect(name)));
     }
 
     return rbType;
@@ -243,7 +201,6 @@ rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
     VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
-    VALUE classEnum = rbffi_EnumTypeClass = rb_define_class_under(moduleFFI, "Enum", classType);
 
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
@@ -270,9 +227,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
     rb_define_method(classBuiltinType, "inspect", builtin_type_inspect, 0);
-
-    rb_define_alloc_func(classEnum, enum_allocate);
-
+    
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
 
@@ -284,29 +239,45 @@ rbffi_Type_Init(VALUE moduleFFI)
         rb_define_const(moduleFFI, "TYPE_" #x, t); \
     } while(0)
 
+    #define A(old_type, new_type) do { \
+        VALUE t = rb_const_get(classType, rb_intern(#old_type)); \
+        rb_const_set(classType, rb_intern(#new_type), t); \
+    } while(0)
+
     T(VOID, &ffi_type_void);
     T(INT8, &ffi_type_sint8);
+    A(INT8, SCHAR);
+    A(INT8, CHAR);
     T(UINT8, &ffi_type_uint8);
+    A(UINT8, UCHAR);
+
     T(INT16, &ffi_type_sint16);
+    A(INT16, SHORT);
+    A(INT16, SSHORT);
     T(UINT16, &ffi_type_uint16);
+    A(UINT16, USHORT);
     T(INT32, &ffi_type_sint32);
+    A(INT32, INT);
+    A(INT32, SINT);
     T(UINT32, &ffi_type_uint32);
+    A(UINT32, UINT);
     T(INT64, &ffi_type_sint64);
+    A(INT64, LONG_LONG);
+    A(INT64, SLONG_LONG);
     T(UINT64, &ffi_type_uint64);
+    A(UINT64, ULONG_LONG);
     T(LONG, &ffi_type_slong);
+    A(LONG, SLONG);
     T(ULONG, &ffi_type_ulong);
     T(FLOAT32, &ffi_type_float);
+    A(FLOAT32, FLOAT);
     T(FLOAT64, &ffi_type_double);
+    A(FLOAT64, DOUBLE);
     T(POINTER, &ffi_type_pointer);
     T(STRING, &ffi_type_pointer);
-    T(RBXSTRING, &ffi_type_pointer);
     T(BUFFER_IN, &ffi_type_pointer);
     T(BUFFER_OUT, &ffi_type_pointer);
     T(BUFFER_INOUT, &ffi_type_pointer);
-    T(ENUM, &ffi_type_sint);
     T(BOOL, &ffi_type_uchar);
-
-
-    T(CHAR_ARRAY, &ffi_type_void);
     T(VARARGS, &ffi_type_void);
 }

data/ext/ffi_c/Type.h

@@ -1,28 +1,19 @@
 /*
  * Copyright (c) 2009, 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:
+ * This file is part of ruby-ffi.
  *
- * * 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 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 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.
+ * 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/>.
  */
 
 #ifndef RBFFI_TYPE_H
@@ -44,8 +35,7 @@ struct Type_ {
     ffi_type* ffiType;
 };
 
-extern VALUE rbffi_TypeClass, rbffi_EnumTypeClass;
-extern int rbffi_Type_GetIntValue(VALUE type);
+extern VALUE rbffi_TypeClass;
 extern VALUE rbffi_Type_Lookup(VALUE type);
 extern VALUE rbffi_Type_Find(VALUE type);
 

data/ext/ffi_c/Types.c

@@ -34,9 +34,10 @@
 #include "StructByValue.h"
 #include "Types.h"
 #include "Struct.h"
+#include "MappedType.h"
 #include "MemoryPointer.h"
 
-static ID id_find = 0;
+static ID id_from_native = 0;
 
 
 VALUE
@@ -77,13 +78,14 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
             return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
-        case NATIVE_ENUM:
-            return rb_funcall(rbType, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
         
         case NATIVE_FUNCTION:
         case NATIVE_CALLBACK: {
-            return rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr));
+            return *(void **) ptr != NULL 
+                    ? rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr))
+                    : Qnil;
         }
+
         case NATIVE_STRUCT: {
             StructByValue* sbv = (StructByValue *)type;
             AbstractMemory* mem;
@@ -95,6 +97,19 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
             return rb_class_new_instance(1, &rbMemory, sbv->rbStructClass);
         }
 
+        case NATIVE_MAPPED: {
+            // For mapped types, first convert to the real native type, then upcall to
+            // ruby to convert to the expected return type
+            MappedType* m;
+            VALUE values[2];
+
+            Data_Get_Struct(rbType, MappedType, m);
+            values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr, enums);
+            values[1] = Qnil;
+
+            return rb_funcall2(m->rbConverter, id_from_native, 2, values);
+        }
+    
         default:
             rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
             return Qnil;
@@ -104,6 +119,6 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
 void
 rbffi_Types_Init(VALUE moduleFFI)
 {
-    id_find = rb_intern("find");
+    id_from_native = rb_intern("from_native");
 }