ffi 0.5.4-x86-mingw32 → 0.6.3-x86-mingw32

data/ext/ffi_c/Struct.h

@@ -39,16 +39,24 @@ extern "C" {
 
     extern void rbffi_Struct_Init(VALUE ffiModule);
     extern void rbffi_StructLayout_Init(VALUE ffiModule);
+    typedef struct StructField_ StructField;
+    typedef struct StructLayout_ StructLayout;
+    typedef struct Struct_ Struct;
 
-    typedef struct StructField_ {
+    struct StructField_ {
         Type* type;
         unsigned int offset;
 
         VALUE rbType;
         VALUE rbName;
-    } StructField;
 
-    typedef struct StructLayout_ {
+        VALUE (*get)(StructField* field, Struct* s);
+        void (*put)(StructField* field, Struct* s, VALUE value);
+
+        MemoryOp* memoryOp;
+    };
+
+    struct StructLayout_ {
         Type base;
         StructField** fields;
         unsigned int fieldCount;
@@ -58,19 +66,20 @@ extern "C" {
         VALUE rbFieldNames;
         VALUE rbFieldMap;
         VALUE rbFields;
-    } StructLayout;
+    };
 
-    typedef struct Struct {
+    struct Struct_ {
         StructLayout* layout;
         AbstractMemory* pointer;
         VALUE rbLayout;
         VALUE rbPointer;
-    } Struct;
+    };
 
     extern VALUE rbffi_StructClass, rbffi_StructLayoutClass;
     extern VALUE rbffi_StructLayoutFieldClass, rbffi_StructLayoutFunctionFieldClass;
-    extern VALUE rbffi_StructLayoutArrayFieldClass, rbffi_StructLayoutStructFieldClass;
+    extern VALUE rbffi_StructLayoutArrayFieldClass;
     extern VALUE rbffi_StructInlineArrayClass;
+    extern VALUE rbffi_StructLayoutCharArrayClass;
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/StructLayout.c

@@ -53,7 +53,6 @@ static void struct_field_mark(StructField* );
 
 VALUE rbffi_StructLayoutFieldClass = Qnil;
 VALUE rbffi_StructLayoutFunctionFieldClass = Qnil, rbffi_StructLayoutArrayFieldClass = Qnil;
-VALUE rbffi_StructLayoutStructFieldClass = Qnil;
 
 VALUE rbffi_StructLayoutClass = Qnil;
 
@@ -105,6 +104,7 @@ struct_field_initialize(int argc, VALUE* argv, VALUE self)
     field->rbName = (TYPE(rbName) == T_SYMBOL) ? rbName : rb_str_intern(rbName);
     field->rbType = rbType;
     Data_Get_Struct(field->rbType, Type, field->type);
+    field->memoryOp = get_memory_op(field->type);
 
     return self;
 }
@@ -134,10 +134,11 @@ struct_field_alignment(VALUE self)
 }
 
 static VALUE
-struct_field_ffi_type(VALUE self)
+struct_field_type(VALUE self)
 {
     StructField* field;
     Data_Get_Struct(self, StructField, field);
+
     return field->rbType;
 }
 
@@ -153,34 +154,28 @@ static VALUE
 struct_field_get(VALUE self, VALUE pointer)
 {
     StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
 
     Data_Get_Struct(self, StructField, f);
-    op = memory_get_op(memory, f->type);
-    if (op == NULL) {
-        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(self));
+    if (f->memoryOp == NULL) {
+        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(f->rbType));
         return Qnil;
     }
 
-    return (*op->get)(memory, f->offset);
+    return (*f->memoryOp->get)(MEMORY(pointer), f->offset);
 }
 
 static VALUE
 struct_field_put(VALUE self, VALUE pointer, VALUE value)
 {
     StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
-
+    
     Data_Get_Struct(self, StructField, f);
-    op = memory_get_op(memory, f->type);
-    if (op == NULL) {
-        rb_raise(rb_eArgError, "put not supported for %s", rb_obj_classname(self));
+    if (f->memoryOp == NULL) {
+        rb_raise(rb_eArgError, "put not supported for %s", rb_obj_classname(f->rbType));
         return self;
     }
 
-    (*op->put)(memory, f->offset, value);
+    (*f->memoryOp->put)(MEMORY(pointer), f->offset, value);
 
     return self;
 }
@@ -189,33 +184,19 @@ static VALUE
 function_field_get(VALUE self, VALUE pointer)
 {
     StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
-
+    
     Data_Get_Struct(self, StructField, f);
-    op = memory->ops->pointer;
-    if (op == NULL) {
-        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(self));
-        return Qnil;
-    }
 
-    return rbffi_Function_NewInstance(f->rbType, (*op->get)(memory, f->offset));
+    return rbffi_Function_NewInstance(f->rbType, (*rbffi_AbstractMemoryOps.pointer->get)(MEMORY(pointer), f->offset));
 }
 
 static VALUE
 function_field_put(VALUE self, VALUE pointer, VALUE proc)
 {
     StructField* f;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
     VALUE value = Qnil;
 
     Data_Get_Struct(self, StructField, f);
-    op = memory->ops->pointer;
-    if (op == NULL) {
-        rb_raise(rb_eArgError, "put not supported for %s", rb_obj_classname(self));
-        return self;
-    }
 
     if (NIL_P(proc) || rb_obj_is_kind_of(proc, rbffi_FunctionClass)) {
         value = proc;
@@ -225,51 +206,110 @@ function_field_put(VALUE self, VALUE pointer, VALUE proc)
         rb_raise(rb_eTypeError, "wrong type (expected Proc or Function)");
     }
 
-    (*op->put)(memory, f->offset, value);
+    (*rbffi_AbstractMemoryOps.pointer->put)(MEMORY(pointer), f->offset, value);
 
     return self;
 }
 
+static inline bool
+isCharArray(ArrayType* arrayType)
+{
+    return arrayType->componentType->nativeType == NATIVE_INT8
+            || arrayType->componentType->nativeType == NATIVE_UINT8;
+}
+
 static VALUE
 array_field_get(VALUE self, VALUE pointer)
 {
     StructField* f;
     ArrayType* array;
-    MemoryOp* op;
-    AbstractMemory* memory = MEMORY(pointer);
     VALUE argv[2];
 
     Data_Get_Struct(self, StructField, f);
     Data_Get_Struct(f->rbType, ArrayType, array);
 
-    op = memory_get_op(memory, array->componentType);
-    if (op == NULL) {
-        rb_raise(rb_eArgError, "get not supported for %s", rb_obj_classname(array->rbComponentType));
-        return Qnil;
-    }
-
     argv[0] = pointer;
     argv[1] = self;
 
-    return rb_class_new_instance(2, argv, rbffi_StructInlineArrayClass);
+    return rb_class_new_instance(2, argv, isCharArray(array)
+            ? rbffi_StructLayoutCharArrayClass : rbffi_StructInlineArrayClass);
 }
 
 static VALUE
-inline_struct_field_get(VALUE self, VALUE pointer)
+array_field_put(VALUE self, VALUE pointer, VALUE value)
 {
     StructField* f;
-    StructByValue* sbv;
-    VALUE rbPointer = Qnil, rbOffset = Qnil;
+    ArrayType* array;
+    
 
     Data_Get_Struct(self, StructField, f);
-    Data_Get_Struct(f->rbType, StructByValue, sbv);
+    Data_Get_Struct(f->rbType, ArrayType, array);
+    
+    if (isCharArray(array) && rb_obj_is_instance_of(value, rb_cString)) {
+        VALUE argv[2];
+
+        argv[0] = INT2FIX(f->offset);
+        argv[1] = value;
 
-    rbOffset = UINT2NUM(f->offset);
-    rbPointer = rb_funcall2(pointer, rb_intern("+"), 1, &rbOffset);
+        rb_funcall2(pointer, rb_intern("put_string"), 2, argv);
 
-    return rb_class_new_instance(1, &rbPointer, sbv->rbStructClass);
+    } else {
+#ifdef notyet
+        MemoryOp* op;
+        int count = RARRAY_LEN(value);
+        int i;
+        AbstractMemory* memory = MEMORY(pointer);
+
+        if (count > array->length) {
+            rb_raise(rb_eIndexError, "array too large");
+        }
+
+        // clear the contents in case of a short write
+        checkWrite(memory);
+        checkBounds(memory, f->offset, f->type->ffiType->size);
+        if (count < array->length) {
+            memset(memory->address + f->offset + (count * array->componentType->ffiType->size),
+                    0, (array->length - count) * array->componentType->ffiType->size);
+        }
+
+        // now copy each element in
+        if ((op = get_memory_op(array->componentType)) != NULL) {
+
+            for (i = 0; i < count; ++i) {
+                (*op->put)(memory, f->offset + (i * array->componentType->ffiType->size), rb_ary_entry(value, i));
+            }
+
+        } else if (array->componentType->nativeType == NATIVE_STRUCT) {
+
+            for (i = 0; i < count; ++i) {
+                VALUE entry = rb_ary_entry(value, i);
+                Struct* s;
+
+                if (!rb_obj_is_kind_of(entry, rbffi_StructClass)) {
+                    rb_raise(rb_eTypeError, "array element not an instance of FFI::Struct");
+                    break;
+                }
+
+                Data_Get_Struct(entry, Struct, s);
+                checkRead(s->pointer);
+                checkBounds(s->pointer, 0, array->componentType->ffiType->size);
+
+                memcpy(memory->address + f->offset + (i * array->componentType->ffiType->size),
+                        s->pointer->address, array->componentType->ffiType->size);
+            }
+
+        } else {
+            rb_raise(rb_eNotImpError, "put not supported for arrays of type %s", rb_obj_classname(array->rbComponentType));
+        }
+#else
+        rb_raise(rb_eNotImpError, "cannot set array field");
+#endif
+    }
+
+    return value;
 }
 
+
 static VALUE
 struct_layout_allocate(VALUE klass)
 {
@@ -309,7 +349,7 @@ struct_layout_initialize(VALUE self, VALUE field_names, VALUE fields, VALUE size
     layout->base.ffiType->alignment = 1;
 
     ltype = layout->base.ffiType;
-    for (i = 0; i < layout->fieldCount; ++i) {
+    for (i = 0; i < (int) layout->fieldCount; ++i) {
         VALUE rbName = rb_ary_entry(field_names, i);
         VALUE rbField = rb_hash_aref(fields, rbName);
         StructField* field;
@@ -405,6 +445,7 @@ struct_layout_free(StructLayout *layout)
     xfree(layout);
 }
 
+
 void
 rbffi_StructLayout_Init(VALUE moduleFFI)
 {
@@ -417,9 +458,6 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rbffi_StructLayoutFunctionFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Function", rbffi_StructLayoutFieldClass);
     rb_global_variable(&rbffi_StructLayoutFunctionFieldClass);
 
-    rbffi_StructLayoutStructFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "StructByValue", rbffi_StructLayoutFieldClass);
-    rb_global_variable(&rbffi_StructLayoutStructFieldClass);
-
     rbffi_StructLayoutArrayFieldClass = rb_define_class_under(rbffi_StructLayoutClass, "Array", rbffi_StructLayoutFieldClass);
     rb_global_variable(&rbffi_StructLayoutArrayFieldClass);
 
@@ -429,7 +467,7 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructLayoutFieldClass, "size", struct_field_size, 0);
     rb_define_method(rbffi_StructLayoutFieldClass, "alignment", struct_field_alignment, 0);
     rb_define_method(rbffi_StructLayoutFieldClass, "name", struct_field_name, 0);
-    rb_define_method(rbffi_StructLayoutFieldClass, "ffi_type", struct_field_ffi_type, 0);
+    rb_define_method(rbffi_StructLayoutFieldClass, "type", struct_field_type, 0);
     rb_define_method(rbffi_StructLayoutFieldClass, "put", struct_field_put, 2);
     rb_define_method(rbffi_StructLayoutFieldClass, "get", struct_field_get, 1);
 
@@ -437,8 +475,7 @@ rbffi_StructLayout_Init(VALUE moduleFFI)
     rb_define_method(rbffi_StructLayoutFunctionFieldClass, "get", function_field_get, 1);
 
     rb_define_method(rbffi_StructLayoutArrayFieldClass, "get", array_field_get, 1);
-    rb_define_method(rbffi_StructLayoutStructFieldClass, "get", inline_struct_field_get, 1);
-
+    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);

data/ext/ffi_c/Type.c

@@ -42,7 +42,7 @@ typedef struct BuiltinType_ {
 
 static void builtin_type_free(BuiltinType *);
 
-VALUE rbffi_TypeClass = Qnil;
+VALUE rbffi_TypeClass = Qnil, rbffi_EnumTypeClass = Qnil;
 
 static VALUE classBuiltinType = Qnil;
 static VALUE typeMap = Qnil, sizeMap = Qnil;
@@ -243,7 +243,7 @@ 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);
+    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());
@@ -293,6 +293,8 @@ rbffi_Type_Init(VALUE moduleFFI)
     T(UINT32, &ffi_type_uint32);
     T(INT64, &ffi_type_sint64);
     T(UINT64, &ffi_type_uint64);
+    T(LONG, &ffi_type_slong);
+    T(ULONG, &ffi_type_ulong);
     T(FLOAT32, &ffi_type_float);
     T(FLOAT64, &ffi_type_double);
     T(POINTER, &ffi_type_pointer);
@@ -302,28 +304,9 @@ rbffi_Type_Init(VALUE moduleFFI)
     T(BUFFER_OUT, &ffi_type_pointer);
     T(BUFFER_INOUT, &ffi_type_pointer);
     T(ENUM, &ffi_type_sint);
-    T(BOOL, &ffi_type_sint);
+    T(BOOL, &ffi_type_uchar);
 
 
     T(CHAR_ARRAY, &ffi_type_void);
     T(VARARGS, &ffi_type_void);
-    
-
-    if (sizeof(long) == 4) {
-        VALUE t = Qnil;
-        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT32, &ffi_type_slong, "LONG"));
-        rb_define_const(moduleNativeType, "LONG", t);
-        rb_define_const(moduleFFI, "TYPE_LONG", t);
-        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT32, &ffi_type_slong, "ULONG"));
-        rb_define_const(moduleNativeType, "ULONG", t);
-        rb_define_const(moduleFFI, "TYPE_ULONG", t);
-    } else {
-        VALUE t = Qnil;
-        rb_define_const(classType, "LONG", t = builtin_type_new(classBuiltinType, NATIVE_INT64, &ffi_type_slong, "LONG"));
-        rb_define_const(moduleNativeType, "LONG", t);
-        rb_define_const(moduleFFI, "TYPE_LONG", t);
-        rb_define_const(classType, "ULONG", t = builtin_type_new(classBuiltinType, NATIVE_UINT64, &ffi_type_slong, "ULONG"));
-        rb_define_const(moduleNativeType, "ULONG", t);
-        rb_define_const(moduleFFI, "TYPE_ULONG", t);
-    }
 }

data/ext/ffi_c/Type.h

@@ -44,7 +44,7 @@ struct Type_ {
     ffi_type* ffiType;
 };
 
-extern VALUE rbffi_TypeClass;
+extern VALUE rbffi_TypeClass, rbffi_EnumTypeClass;
 extern int rbffi_Type_GetIntValue(VALUE type);
 extern VALUE rbffi_Type_Lookup(VALUE type);
 extern VALUE rbffi_Type_Find(VALUE type);

data/ext/ffi_c/Types.c

@@ -51,16 +51,22 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
           return INT2NUM((signed short) *(ffi_sarg *) ptr);
         case NATIVE_INT32:
           return INT2NUM((signed int) *(ffi_sarg *) ptr);
+        case NATIVE_LONG:
+            return LONG2NUM((signed long) *(ffi_sarg *) ptr);
+        case NATIVE_INT64:
+            return LL2NUM(*(signed long long *) ptr);
+
         case NATIVE_UINT8:
           return UINT2NUM((unsigned char) *(ffi_arg *) ptr);
         case NATIVE_UINT16:
           return UINT2NUM((unsigned short) *(ffi_arg *) ptr);
         case NATIVE_UINT32:
           return UINT2NUM((unsigned int) *(ffi_arg *) ptr);
-        case NATIVE_INT64:
-            return LL2NUM(*(signed long long *) ptr);
+        case NATIVE_ULONG:
+            return ULONG2NUM((unsigned long) *(ffi_arg *) ptr);
         case NATIVE_UINT64:
             return ULL2NUM(*(unsigned long long *) ptr);
+
         case NATIVE_FLOAT32:
             return rb_float_new(*(float *) ptr);
         case NATIVE_FLOAT64:
@@ -70,7 +76,7 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
         case NATIVE_POINTER:
             return rbffi_Pointer_NewInstance(*(void **) ptr);
         case NATIVE_BOOL:
-            return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
+            return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
         case NATIVE_ENUM:
             return rb_funcall(rbType, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
         

data/ext/ffi_c/Types.h

@@ -44,6 +44,8 @@ typedef enum {
     NATIVE_UINT32,
     NATIVE_INT64,
     NATIVE_UINT64,
+    NATIVE_LONG,
+    NATIVE_ULONG,
     NATIVE_FLOAT32,
     NATIVE_FLOAT64,
     NATIVE_POINTER,

data/ext/ffi_c/extconf.rb

@@ -4,21 +4,25 @@ require 'rbconfig'
 dir_config("ffi_c")
 
 unless Config::CONFIG['host_os'] =~ /mswin32|mingw32/
-  pkg_config("libffi") || find_header("ffi.h", "/usr/local/include", "/opt/local/include")
-  have_ffi_call = have_library("ffi", "ffi_call", [ "ffi.h" ])
-  have_prep_closure = have_func("ffi_prep_closure")
-  libffi_ok = have_ffi_call && have_prep_closure
-  $defs << "-DHAVE_LIBFFI" if libffi_ok
-  $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
+  if pkg_config("libffi") || find_header("ffi.h", "/usr/local/include")
+
+    # We need at least ffi_call and ffi_prep_closure
+    libffi_ok = have_library("ffi", "ffi_call", [ "ffi.h" ]) && have_func("ffi_prep_closure")
+    
+    # Check if the raw api is available.
+    $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
+  end
 end
+
 have_func('rb_thread_blocking_region')
 
 $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
+$defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
 
 create_header
 
 $CFLAGS << " -mwin32 " if Config::CONFIG['host_os'] =~ /cygwin/
-$CFLAGS << " -Werror -Wunused -Wformat -Wimplicit -Wreturn-type "
+#$CFLAGS << " -Werror -Wunused -Wformat -Wimplicit -Wreturn-type "
 
 create_makefile("ffi_c")
 unless libffi_ok