ffi 0.4.0-x86-mswin32 → 0.5.0-x86-mswin32

data/ext/ffi_c/Type.c

@@ -1,3 +1,30 @@
+/*
+ * 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.
+ * * 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 <ruby.h>
@@ -18,6 +45,8 @@ static void builtin_type_free(BuiltinType *);
 VALUE rbffi_TypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
+static VALUE typeMap = Qnil, sizeMap = Qnil;
+static ID id_find_type = 0, id_type_size = 0, id_size = 0;
 
 static VALUE
 type_allocate(VALUE klass)
@@ -26,9 +55,8 @@ type_allocate(VALUE klass)
     VALUE obj = Data_Make_Struct(klass, Type, NULL, -1, type);
 
     type->nativeType = -1;
-    type->size = 0;
-    type->alignment = 1;
-
+    type->ffiType = &ffi_type_void;
+    
     return obj;
 }
 
@@ -45,8 +73,7 @@ type_initialize(VALUE self, VALUE value)
     } else if (rb_obj_is_kind_of(value, rbffi_TypeClass)) {
         Data_Get_Struct(value, Type, other);
         type->nativeType = other->nativeType;
-        type->size = other->size;
-        type->alignment = other->alignment;
+        type->ffiType = other->ffiType;
     } else {
         rb_raise(rb_eArgError, "wrong type");
     }
@@ -61,7 +88,7 @@ type_size(VALUE self)
 
     Data_Get_Struct(self, Type, type);
 
-    return INT2FIX(type->size);
+    return INT2FIX(type->ffiType->size);
 }
 
 static VALUE
@@ -71,7 +98,7 @@ type_alignment(VALUE self)
 
     Data_Get_Struct(self, Type, type);
 
-    return INT2FIX(type->alignment);
+    return INT2FIX(type->ffiType->alignment);
 }
 
 static VALUE
@@ -82,7 +109,7 @@ type_inspect(VALUE self)
 
     Data_Get_Struct(self, Type, type);
     snprintf(buf, sizeof(buf), "#<FFI::Type:%p size=%d alignment=%d>", 
-            type, type->size, type->alignment);
+            type, (int) type->ffiType->size, (int) type->ffiType->alignment);
 
     return rb_str_new2(buf);
 }
@@ -96,8 +123,6 @@ enum_allocate(VALUE klass)
     obj = Data_Make_Struct(klass, Type, NULL, -1, type);
     type->nativeType = NATIVE_ENUM;
     type->ffiType = &ffi_type_sint;
-    type->size = ffi_type_sint.size;
-    type->alignment = ffi_type_sint.alignment;
 
     return obj;
 }
@@ -105,26 +130,28 @@ enum_allocate(VALUE klass)
 int
 rbffi_Type_GetIntValue(VALUE type)
 {
-    if (rb_obj_is_kind_of(type, rbffi_TypeClass)) {
-        Type* t;
-        Data_Get_Struct(type, Type, t);
-        return t->nativeType;
-    } else {
-        rb_raise(rb_eArgError, "Invalid type argument");
+    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;
 }
 
 static VALUE
 builtin_type_new(VALUE klass, int nativeType, ffi_type* ffiType, const char* name)
 {
     BuiltinType* type;
-    VALUE obj = Data_Make_Struct(klass, BuiltinType, NULL, builtin_type_free, type);
+    VALUE obj = Qnil;
+
+    obj = Data_Make_Struct(klass, BuiltinType, NULL, builtin_type_free, type);
     
     type->name = strdup(name);
     type->type.nativeType = nativeType;
     type->type.ffiType = ffiType;
-    type->type.size = ffiType->size;
-    type->type.alignment = ffiType->alignment;
 
     return obj;
 }
@@ -143,18 +170,90 @@ builtin_type_inspect(VALUE self)
     BuiltinType *type;
 
     Data_Get_Struct(self, BuiltinType, type);
-    snprintf(buf, sizeof(buf), "#<FFI::Type::Builtin:%ssize=%d alignment=%d>",
-            type->name, type->type.size, type->type.alignment);
+    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);
 }
 
+int
+rbffi_type_size(VALUE type)
+{
+    int t = TYPE(type);
+    if (t == T_FIXNUM || t == T_BIGNUM) {
+        return NUM2INT(type);
+    } else if (t == T_SYMBOL) {
+        /*
+         * Try looking up directly in the type and size maps
+         */
+        VALUE nType;
+        if ((nType = rb_hash_aref(typeMap, type)) != Qnil) {
+            VALUE nSize = rb_hash_aref(sizeMap, nType);
+            if (TYPE(nSize) == T_FIXNUM) {
+                return FIX2INT(nSize);
+            }
+        }
+        // Not found - call up to the ruby version to resolve
+        return NUM2INT(rb_funcall2(rbffi_FFIModule, id_type_size, 1, &type));
+    } else {
+        return NUM2INT(rb_funcall2(type, id_size, 0, NULL));
+    }
+}
+
+VALUE
+rbffi_Type_Lookup(VALUE name)
+{
+    int t = TYPE(name);
+    if (t == T_SYMBOL || t == T_STRING) {
+        /*
+         * Try looking up directly in the type Map
+         */
+        VALUE nType;
+        if ((nType = rb_hash_aref(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+            return nType;
+        }
+    } else if (rb_obj_is_kind_of(name, rbffi_TypeClass)) {
+    
+        return name;
+    }
+
+    /* Nothing found - let caller handle raising exceptions */
+    return Qnil;
+}
+
+/**
+ * rbffi_Type_Find() is like rbffi_Type_Lookup, but an error is raised if the
+ * type is not found.
+ */
+VALUE
+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));
+    }
+
+    return rbType;
+}
+
 void
 rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
     VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
     VALUE classEnum =  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());
+    rb_global_variable(&typeMap);
+    rb_global_variable(&sizeMap);
+    id_find_type = rb_intern("find_type");
+    id_type_size = rb_intern("type_size");
+    id_size = rb_intern("size");
+
+
     classBuiltinType = rb_define_class_under(rbffi_TypeClass, "Builtin", rbffi_TypeClass);
     moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
 
@@ -166,7 +265,7 @@ rbffi_Type_Init(VALUE moduleFFI)
     rb_define_method(classType, "initialize", type_initialize, 1);
     rb_define_method(classType, "size", type_size, 0);
     rb_define_method(classType, "alignment", type_alignment, 0);
-    rb_define_method(classBuiltinType, "inspect", type_inspect, 0);
+    rb_define_method(classType, "inspect", type_inspect, 0);
 
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");

data/ext/ffi_c/Type.h

@@ -1,5 +1,32 @@
-#ifndef _TYPE_H
-#define	_TYPE_H
+/*
+ * 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.
+ * * 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.
+ */
+
+#ifndef RBFFI_TYPE_H
+#define	RBFFI_TYPE_H
 
 #include <ruby.h>
 #include <ffi.h>
@@ -8,21 +35,23 @@
 extern "C" {
 #endif
 
+typedef struct Type_ Type;
+
+#include "Types.h"
     
-typedef struct Type_ {
+struct Type_ {
     NativeType nativeType;
     ffi_type* ffiType;
-    int size;
-    int alignment;
-} Type;
+};
 
 extern VALUE rbffi_TypeClass;
 extern int rbffi_Type_GetIntValue(VALUE type);
-
+extern VALUE rbffi_Type_Lookup(VALUE type);
+extern VALUE rbffi_Type_Find(VALUE type);
 
 #ifdef	__cplusplus
 }
 #endif
 
-#endif	/* _TYPE_H */
+#endif	/* RBFFI_TYPE_H */
 

data/ext/ffi_c/Types.c

@@ -1,51 +1,43 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich
+ * Copyright (c) 2009, Aman Gupta.
+ * 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 <ruby.h>
 #include "Pointer.h"
 #include "rbffi.h"
-#include "Callback.h"
+#include "Function.h"
+#include "StructByValue.h"
 #include "Types.h"
+#include "Struct.h"
+#include "MemoryPointer.h"
 
 static ID id_find = 0;
 
-ffi_type*
-rbffi_NativeType_ToFFI(NativeType type)
-{
-    switch (type) {
-        case NATIVE_VOID:
-            return &ffi_type_void;
-        case NATIVE_INT8:
-            return &ffi_type_sint8;
-        case NATIVE_UINT8:
-            return &ffi_type_uint8;
-        case NATIVE_INT16:
-            return &ffi_type_sint16;
-        case NATIVE_UINT16:
-            return &ffi_type_uint16;
-        case NATIVE_BOOL:
-        case NATIVE_INT32:
-        case NATIVE_ENUM:
-            return &ffi_type_sint32;
-        case NATIVE_UINT32:
-            return &ffi_type_uint32;
-        case NATIVE_INT64:
-            return &ffi_type_sint64;
-        case NATIVE_UINT64:
-            return &ffi_type_uint64;
-        case NATIVE_FLOAT32:
-            return &ffi_type_float;
-        case NATIVE_FLOAT64:
-            return &ffi_type_double;
-        case NATIVE_STRING:
-        case NATIVE_RBXSTRING:
-        case NATIVE_POINTER:
-        case NATIVE_BUFFER_IN:
-        case NATIVE_BUFFER_OUT:
-        case NATIVE_BUFFER_INOUT:
-        case NATIVE_CALLBACK:
-            return &ffi_type_pointer;
-        default:
-            return NULL;
-    }
-}
 
 VALUE
 rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
@@ -74,34 +66,27 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
         case NATIVE_FLOAT64:
             return rb_float_new(*(double *) ptr);
         case NATIVE_STRING:
-            return (*(char **)ptr) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
+            return (*(void **) ptr != NULL) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
         case NATIVE_POINTER:
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
             return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
         case NATIVE_ENUM:
-        {
-            VALUE enum_obj = rb_funcall(enums, id_find, 1, rbType);
-            if (enum_obj == Qnil) {
-                VALUE s = rb_inspect(rbType);
-                rb_raise(rb_eRuntimeError, "Unknown enumeration: %s", StringValueCStr(s));
-            }
-            return rb_funcall(enum_obj, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
-        }
+            return rb_funcall(rbType, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
+        
+        case NATIVE_FUNCTION:
         case NATIVE_CALLBACK: {
-            CallbackInfo* cbInfo;
-            VALUE argv[6];
-            VALUE funcptr = rbffi_Pointer_NewInstance(*(void **) ptr);
+            return rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr));
+        }
+        case NATIVE_STRUCT: {
+            StructByValue* sbv = (StructByValue *)type;
+            AbstractMemory* mem;
+            VALUE rbMemory = rbffi_MemoryPointer_NewInstance(1, sbv->base.ffiType->size, false);
 
-            Data_Get_Struct(rbType, CallbackInfo, cbInfo);
-            argv[0] = funcptr;
-            argv[1] = cbInfo->rbParameterTypes;
-            argv[2] = ID2SYM(rb_intern("cb")); // just shove a dummy value
-            argv[3] = cbInfo->rbReturnType;
-            argv[4] = rb_str_new2("default");
-            argv[5] = Qnil;
+            Data_Get_Struct(rbMemory, AbstractMemory, mem);
+            memcpy(mem->address, ptr, sbv->base.ffiType->size);
 
-            return rb_class_new_instance(6, argv, rbffi_InvokerClass);
+            return rb_class_new_instance(1, &rbMemory, sbv->rbStructClass);
         }
 
         default:

data/ext/ffi_c/Types.h

@@ -1,12 +1,39 @@
-#ifndef _TYPES_H
-#define	_TYPES_H
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
+ *
+ * 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.
+ */
+
+#ifndef RBFFI_TYPES_H
+#define	RBFFI_TYPES_H
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
-#ifdef VOID
-#  undef VOID
-#endif
+
 typedef enum {
     NATIVE_VOID,
     NATIVE_INT8,
@@ -21,6 +48,7 @@ typedef enum {
     NATIVE_FLOAT64,
     NATIVE_POINTER,
     NATIVE_CALLBACK,
+    NATIVE_FUNCTION,
     NATIVE_BUFFER_IN,
     NATIVE_BUFFER_OUT,
     NATIVE_BUFFER_INOUT,
@@ -37,12 +65,15 @@ typedef enum {
     NATIVE_VARARGS,
     /** A typedef-ed enum */
     NATIVE_ENUM,
+    /** Struct-by-value param or result */
+    NATIVE_STRUCT,
+    /** An array type definition */
+    NATIVE_ARRAY,
 } NativeType;
 
 #include <ffi.h>
 #include "Type.h"
 
-extern ffi_type* rbffi_NativeType_ToFFI(NativeType type);
 VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums);
 void rbffi_Types_Init(VALUE moduleFFI);
 
@@ -50,5 +81,5 @@ void rbffi_Types_Init(VALUE moduleFFI);
 }
 #endif
 
-#endif	/* _TYPES_H */
+#endif	/* RBFFI_TYPES_H */