ffi 0.5.0 → 0.6.0

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:

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/Variadic.c

@@ -145,28 +145,12 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     return retval;
 }
 
-
-static inline VALUE
-ffi_invoke(ffi_cif* cif, void* function, Type* returnType, void** ffiValues,
-    VALUE rbReturnType, VALUE rbEnums)
-{
-    FFIStorage retval;
-
-#ifdef USE_RAW
-    ffi_raw_call(cif, function, &retval, (ffi_raw *) ffiValues[0]);
-#else
-    ffi_call(cif, function, &retval, ffiValues);
-#endif
-    rbffi_save_errno();
-
-    return rbffi_NativeValue_ToRuby(returnType, rbReturnType, &retval, rbEnums);
-}
-
 static VALUE
 variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 {
     VariadicInvoker* invoker;
     FFIStorage* params;
+    void* retval;
     ffi_cif cif;
     void** ffiValues;
     ffi_type** ffiParamTypes;
@@ -186,6 +170,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     params = ALLOCA_N(FFIStorage, paramCount);
     ffiValues = ALLOCA_N(void*, paramCount);
     argv = ALLOCA_N(VALUE, paramCount);
+    retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
 
     for (i = 0; i < paramCount; ++i) {
         VALUE entry = rb_ary_entry(parameterTypes, i);
@@ -241,8 +226,11 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
         ffiValues, NULL, 0, invoker->rbEnums);
 
-    return ffi_invoke(&cif, invoker->function, invoker->returnType,
-        ffiValues, invoker->rbReturnType, invoker->rbEnums);
+    ffi_call(&cif, invoker->function, retval, ffiValues);
+
+    rbffi_save_errno();
+
+    return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval, invoker->rbEnums);
 }
 
 

data/ext/ffi_c/endian.h

@@ -4,7 +4,7 @@
 #include <sys/param.h>
 #include <sys/types.h>
 
-#ifdef __linux__
+#if defined(__linux__) || defined(__CYGWIN__)
 #  include_next <endian.h>
 #endif
 

data/ext/ffi_c/extconf.rb

@@ -3,22 +3,31 @@ require 'mkmf'
 require 'rbconfig'
 dir_config("ffi_c")
 
-IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
-have_closure_alloc = have_library("ffi", "ffi_closure_alloc", [ "ffi.h" ])
-$defs.push("-DHAVE_FFI_CLOSURE_ALLOC") if have_closure_alloc
-libffi_ok = have_closure_alloc && !IS_MAC
-$defs << "-DHAVE_LIBFFI" if libffi_ok
-$defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
+unless Config::CONFIG['host_os'] =~ /mswin32|mingw32/
+  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 "
+
 create_makefile("ffi_c")
-create_header("extconf.h")
-File.open("Makefile", "a") do |mf|
-  mf.puts "CPPFLAGS += -Werror -Wunused -Wformat -Wimplicit -Wreturn-type"
-  unless libffi_ok 
+unless libffi_ok
+  File.open("Makefile", "a") do |mf|
     mf.puts "LIBFFI_HOST=--host=#{Config::CONFIG['host_alias']}" if Config::CONFIG.has_key?("host_alias")
-    mf.puts "FFI_MMAP_EXEC=-DFFI_MMAP_EXEC_WRIT=#{Config::CONFIG['host_os'] =~ /(win32|mingw)/ ? 0 : 1}"
     if Config::CONFIG['host_os'].downcase =~ /darwin/
       mf.puts "include ${srcdir}/libffi.darwin.mk"
     elsif Config::CONFIG['host_os'].downcase =~ /bsd/