ffi 0.4.0 → 0.5.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ffi
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Wayne Meissner
@@ -9,16 +9,35 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-05 00:00:00 +02:00
+date: 2009-10-06 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.1
+    version: 
 description: |-
   Ruby-FFI is a ruby extension for programmatically loading dynamic
   libraries, binding functions within them, and calling those functions
   from Ruby code. Moreover, a Ruby-FFI extension works without changes
   on Ruby and JRuby. Discover why should you write your next extension
-  using Ruby-FFI {here}[http://kenai.com/projects/ruby-ffi/pages/WhyUseFFI].
+  using Ruby-FFI here[http://wiki.github.com/ffi/ffi/why-use-ffi].
 email: wmeissner@gmail.com
 executables: []
 
@@ -33,29 +52,40 @@ files:
 - Rakefile
 - ext/ffi_c/AbstractMemory.c
 - ext/ffi_c/AbstractMemory.h
+- ext/ffi_c/ArrayType.c
+- ext/ffi_c/ArrayType.h
 - ext/ffi_c/AutoPointer.c
 - ext/ffi_c/AutoPointer.h
 - ext/ffi_c/Buffer.c
-- ext/ffi_c/Callback.c
-- ext/ffi_c/Callback.h
+- ext/ffi_c/Call.c
+- ext/ffi_c/Call.h
+- ext/ffi_c/ClosurePool.c
+- ext/ffi_c/ClosurePool.h
 - ext/ffi_c/DynamicLibrary.c
 - ext/ffi_c/DynamicLibrary.h
-- ext/ffi_c/Invoker.c
+- ext/ffi_c/Function.c
+- ext/ffi_c/Function.h
+- ext/ffi_c/FunctionInfo.c
 - ext/ffi_c/LastError.c
 - ext/ffi_c/LastError.h
 - ext/ffi_c/MemoryPointer.c
 - ext/ffi_c/MemoryPointer.h
-- ext/ffi_c/NullPointer.c
+- ext/ffi_c/MethodHandle.c
+- ext/ffi_c/MethodHandle.h
 - ext/ffi_c/Platform.c
 - ext/ffi_c/Platform.h
 - ext/ffi_c/Pointer.c
 - ext/ffi_c/Pointer.h
 - ext/ffi_c/Struct.c
 - ext/ffi_c/Struct.h
+- ext/ffi_c/StructByValue.c
+- ext/ffi_c/StructByValue.h
+- ext/ffi_c/StructLayout.c
 - ext/ffi_c/Type.c
 - ext/ffi_c/Type.h
 - ext/ffi_c/Types.c
 - ext/ffi_c/Types.h
+- ext/ffi_c/Variadic.c
 - ext/ffi_c/compat.h
 - ext/ffi_c/endian.h
 - ext/ffi_c/extconf.rb
@@ -324,6 +354,7 @@ files:
 - spec/ffi/callback_spec.rb
 - spec/ffi/enum_spec.rb
 - spec/ffi/errno_spec.rb
+- spec/ffi/function_spec.rb
 - spec/ffi/library_spec.rb
 - spec/ffi/managed_struct_spec.rb
 - spec/ffi/number_spec.rb
@@ -342,7 +373,7 @@ files:
 - spec/ffi/variadic_spec.rb
 - spec/spec.opts
 has_rdoc: true
-homepage: http://kenai.com/projects/ruby-ffi
+homepage: http://wiki.github.com/ffi/ffi
 licenses: []
 
 post_install_message: 
@@ -369,7 +400,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ffi
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Ruby-FFI is a ruby extension for programmatically loading dynamic libraries, binding functions within them, and calling those functions from Ruby code

data/ext/ffi_c/Callback.c

@@ -1,374 +0,0 @@
-#include <sys/param.h>
-#include <sys/types.h>
-#ifndef _WIN32
-# include <sys/mman.h>
-#endif
-#include <ruby.h>
-#include <ffi.h>
-#include "AbstractMemory.h"
-#include "Pointer.h"
-#include "MemoryPointer.h"
-#include "Callback.h"
-#include "Types.h"
-#include "Type.h"
-#include "rbffi.h"
-#include "compat.h"
-#include "extconf.h"
-
-static void cbinfo_mark(CallbackInfo* cbInfo);
-static void cbinfo_free(CallbackInfo *);
-
-#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
-static void* ffi_closure_alloc(size_t size, void** code);
-static void ffi_closure_free(void* ptr);
-ffi_status ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
-        void (*fun)(ffi_cif*, void*, void**, void*),
-        void* user_data, void* code);
-#endif /* HAVE_FFI_CLOSURE_ALLOC */
-
-static VALUE CallbackInfoClass = Qnil;
-static VALUE NativeCallbackClass = Qnil;
-static ID id_call = Qnil, id_cbtable = Qnil;
-
-VALUE rbffi_CallbackInfoClass = Qnil;
-
-static VALUE
-cbinfo_allocate(VALUE klass)
-{
-    CallbackInfo* cbInfo;
-    VALUE obj = Data_Make_Struct(klass, CallbackInfo, cbinfo_mark, cbinfo_free, cbInfo);
-
-    cbInfo->type.ffiType = &ffi_type_pointer;
-    cbInfo->type.size = ffi_type_pointer.size;
-    cbInfo->type.alignment = ffi_type_pointer.alignment;
-    cbInfo->type.nativeType = NATIVE_CALLBACK;
-    cbInfo->rbReturnType = Qnil;
-
-    return obj;
-}
-
-static VALUE
-cbinfo_initialize(VALUE self, VALUE rbReturnType, VALUE rbParamTypes)
-{
-    CallbackInfo *cbInfo;
-    int paramCount;
-    ffi_status status;
-    int i;
-
-    Check_Type(rbParamTypes, T_ARRAY);
-
-    
-    paramCount = RARRAY_LEN(rbParamTypes);
-
-    Data_Get_Struct(self, CallbackInfo, cbInfo);
-    cbInfo->parameterCount = paramCount;
-    cbInfo->parameterTypes = xcalloc(paramCount, sizeof(*cbInfo->parameterTypes));
-    cbInfo->ffiParameterTypes = xcalloc(paramCount, sizeof(ffi_type *));
-    Data_Get_Struct(rbReturnType, Type, cbInfo->returnType);
-    cbInfo->rbReturnType = rbReturnType;
-    cbInfo->rbParameterTypes = rbParamTypes;
-
-    for (i = 0; i < paramCount; ++i) {
-        VALUE entry = rb_ary_entry(rbParamTypes, i);
-        if (!rb_obj_is_kind_of(entry, rbffi_TypeClass)) {
-            rb_raise(rb_eTypeError, "Invalid parameter type");
-        }
-        Data_Get_Struct(entry, Type, cbInfo->parameterTypes[i]);
-        cbInfo->ffiParameterTypes[i] = cbInfo->parameterTypes[i]->ffiType;
-        if (cbInfo->ffiParameterTypes[i] == NULL) {
-            rb_raise(rb_eArgError, "Unknown argument type: %#x", cbInfo->parameterTypes[i]->nativeType);
-        }
-    }
-
-    if (!rb_obj_is_kind_of(rbReturnType, rbffi_TypeClass)) {
-        rb_raise(rb_eTypeError, "Invalid return type");
-    }
-
-    cbInfo->ffiReturnType = cbInfo->returnType->ffiType;
-    if (cbInfo->ffiReturnType == NULL) {
-        rb_raise(rb_eArgError, "Unknown return type: %#x", cbInfo->returnType->nativeType);
-    }
-#if defined(_WIN32) && defined(notyet)
-    cbInfo->abi = (flags & STDCALL) ? FFI_STDCALL : FFI_DEFAULT_ABI;
-#else
-    cbInfo->abi = FFI_DEFAULT_ABI;
-#endif
-    status = ffi_prep_cif(&cbInfo->ffi_cif, cbInfo->abi, cbInfo->parameterCount, 
-            cbInfo->ffiReturnType, cbInfo->ffiParameterTypes);
-    switch (status) {
-        case FFI_BAD_ABI:
-            rb_raise(rb_eArgError, "Invalid ABI specified");
-        case FFI_BAD_TYPEDEF:
-            rb_raise(rb_eArgError, "Invalid argument type specified");
-        case FFI_OK:
-            break;
-        default:
-            rb_raise(rb_eArgError, "Unknown FFI error");
-    }
-    return self;
-}
-
-static void
-cbinfo_mark(CallbackInfo* cbInfo)
-{
-    rb_gc_mark(cbInfo->rbReturnType);
-    rb_gc_mark(cbInfo->rbParameterTypes);
-}
-
-static void
-cbinfo_free(CallbackInfo* cbInfo)
-{
-    if (cbInfo->parameterTypes != NULL) {
-        xfree(cbInfo->parameterTypes);
-    }
-    if (cbInfo->ffiParameterTypes != NULL) {
-        xfree(cbInfo->ffiParameterTypes);
-    }
-    xfree(cbInfo);
-}
-
-static void
-native_callback_free(NativeCallback* cb)
-{
-    if (cb->ffi_closure != NULL) {
-        ffi_closure_free(cb->ffi_closure);
-    }
-    xfree(cb);
-}
-
-static void
-native_callback_mark(NativeCallback* cb)
-{
-    rb_gc_mark(cb->rbCallbackInfo);
-    rb_gc_mark(cb->rbProc);
-}
-
-static void
-native_callback_invoke(ffi_cif* cif, void* retval, void** parameters, void* user_data)
-{
-    NativeCallback* cb = (NativeCallback *) user_data;
-    CallbackInfo *cbInfo = cb->cbInfo;
-    VALUE* rbParams;
-    VALUE rbReturnValue;
-    int i;
-
-    rbParams = ALLOCA_N(VALUE, cbInfo->parameterCount);
-    for (i = 0; i < cbInfo->parameterCount; ++i) {
-        VALUE param;
-        switch (cbInfo->parameterTypes[i]->nativeType) {
-            case NATIVE_INT8:
-                param = INT2NUM(*(int8_t *) parameters[i]);
-                break;
-            case NATIVE_UINT8:
-                param = UINT2NUM(*(uint8_t *) parameters[i]);
-                break;
-            case NATIVE_INT16:
-                param = INT2NUM(*(int16_t *) parameters[i]);
-                break;
-            case NATIVE_UINT16:
-                param = UINT2NUM(*(uint16_t *) parameters[i]);
-                break;
-            case NATIVE_INT32:
-                param = INT2NUM(*(int32_t *) parameters[i]);
-                break;
-            case NATIVE_UINT32:
-                param = UINT2NUM(*(uint32_t *) parameters[i]);
-                break;
-            case NATIVE_INT64:
-                param = LL2NUM(*(int64_t *) parameters[i]);
-                break;
-            case NATIVE_UINT64:
-                param = ULL2NUM(*(uint64_t *) parameters[i]);
-                break;
-            case NATIVE_FLOAT32:
-                param = rb_float_new(*(float *) parameters[i]);
-                break;
-            case NATIVE_FLOAT64:
-                param = rb_float_new(*(double *) parameters[i]);
-                break;
-            case NATIVE_STRING:
-                param = rb_tainted_str_new2(*(char **) parameters[i]);
-                break;
-            case NATIVE_POINTER:
-                param = rbffi_Pointer_NewInstance(*(void **) parameters[i]);
-                break;
-            case NATIVE_BOOL:
-                param = (*(void **) parameters[i]) ? Qtrue : Qfalse;
-                break;
-            case NATIVE_CALLBACK:
-                param = rbffi_NativeValue_ToRuby(cbInfo->parameterTypes[i],
-                     rb_ary_entry(cbInfo->rbParameterTypes, i), parameters[i], Qnil);
-                break;
-            default:
-                param = Qnil;
-                break;
-        }
-        rbParams[i] = param;
-    }
-    rbReturnValue = rb_funcall2(cb->rbProc, id_call, cbInfo->parameterCount, rbParams);
-    if (rbReturnValue == Qnil || TYPE(rbReturnValue) == T_NIL) {
-        memset(retval, 0, cbInfo->ffiReturnType->size);
-    } else switch (cbInfo->returnType->nativeType) {
-        case NATIVE_INT8:
-        case NATIVE_INT16:
-        case NATIVE_INT32:
-            *((ffi_sarg *) retval) = NUM2INT(rbReturnValue);
-            break;
-        case NATIVE_UINT8:
-        case NATIVE_UINT16:
-        case NATIVE_UINT32:
-            *((ffi_arg *) retval) = NUM2UINT(rbReturnValue);
-            break;
-        case NATIVE_INT64:
-            *((int64_t *) retval) = NUM2LL(rbReturnValue);
-            break;
-        case NATIVE_UINT64:
-            *((uint64_t *) retval) = NUM2ULL(rbReturnValue);
-            break;
-        case NATIVE_FLOAT32:
-            *((float *) retval) = (float) NUM2DBL(rbReturnValue);
-            break;
-        case NATIVE_FLOAT64:
-            *((double *) retval) = NUM2DBL(rbReturnValue);
-            break;
-        case NATIVE_POINTER:
-            if (TYPE(rbReturnValue) == T_DATA && rb_obj_is_kind_of(rbReturnValue, rbffi_PointerClass)) {
-                *((void **) retval) = ((AbstractMemory *) DATA_PTR(rbReturnValue))->address;
-            } else {
-                // Default to returning NULL if not a value pointer object.  handles nil case as well
-                *((void **) retval) = NULL;
-            }
-            break;
-        case NATIVE_BOOL:
-            *((ffi_sarg *) retval) = TYPE(rbReturnValue) == T_TRUE ? 1 : 0;
-            break;
-        case NATIVE_CALLBACK:
-            if (rb_obj_is_kind_of(rbReturnValue, rb_cProc) || rb_respond_to(rbReturnValue, id_call)) {
-                VALUE callback;
-
-                callback = rbffi_NativeCallback_ForProc(rbReturnValue, cbInfo->rbReturnType);
-                
-                *((void **) retval) = ((NativeCallback *) DATA_PTR(callback))->code;
-            } else {
-                *((void **) retval) = NULL;
-            }
-            break;
-
-        default:
-            *((ffi_arg *) retval) = 0;
-            break;
-    }
-}
-
-static VALUE
-native_callback_allocate(VALUE klass)
-{
-    NativeCallback* closure;
-    VALUE obj;
-
-    obj = Data_Make_Struct(klass, NativeCallback, native_callback_mark, native_callback_free, closure);
-    closure->rbCallbackInfo = Qnil;
-    closure->rbProc = Qnil;
-    
-    return obj;
-}
-
-VALUE
-rbffi_NativeCallback_NewInstance(VALUE rbCallbackInfo, VALUE rbProc)
-{
-    NativeCallback* closure = NULL;
-    CallbackInfo* cbInfo;
-    VALUE obj;
-    ffi_status status;
-
-    Data_Get_Struct(rbCallbackInfo, CallbackInfo, cbInfo);
-    obj = Data_Make_Struct(NativeCallbackClass, NativeCallback, native_callback_mark, native_callback_free, closure);
-    closure->cbInfo = cbInfo;
-    closure->rbProc = rbProc;
-    closure->rbCallbackInfo = rbCallbackInfo;
-
-    closure->ffi_closure = ffi_closure_alloc(sizeof(*closure->ffi_closure), &closure->code);
-    if (closure->ffi_closure == NULL) {
-        rb_raise(rb_eNoMemError, "Failed to allocate FFI native closure");
-    }
-
-    status = ffi_prep_closure_loc(closure->ffi_closure, &cbInfo->ffi_cif,
-            native_callback_invoke, closure, closure->code);
-    if (status != FFI_OK) {
-        rb_raise(rb_eArgError, "ffi_prep_closure_loc failed");
-    }
-
-    return obj;
-}
-
-VALUE
-rbffi_NativeCallback_ForProc(VALUE proc, VALUE cbInfo)
-{
-    VALUE callback;
-    VALUE cbTable = RTEST(rb_ivar_defined(proc, id_cbtable)) ? rb_ivar_get(proc, id_cbtable) : Qnil;
-    if (cbTable == Qnil) {
-        cbTable = rb_hash_new();
-        rb_ivar_set(proc, id_cbtable, cbTable);
-    }
-    callback = rb_hash_aref(cbTable, cbInfo);
-    if (callback != Qnil) {
-        return callback;
-    }
-    callback = rbffi_NativeCallback_NewInstance(cbInfo, proc);
-    rb_hash_aset(cbTable, cbInfo, callback);
-    return callback;
-}
-#if defined(HAVE_LIBFFI) && !defined(HAVE_FFI_CLOSURE_ALLOC)
-/*
- * versions of ffi_closure_alloc, ffi_closure_free and ffi_prep_closure_loc for older
- * system libffi versions.
- */
-static void*
-ffi_closure_alloc(size_t size, void** code)
-{
-    void* closure;
-    closure = mmap(NULL, size, PROT_READ | PROT_WRITE,
-             MAP_ANON | MAP_PRIVATE, -1, 0);
-    if (closure == (void *) -1) {
-        return NULL;
-    }
-    memset(closure, 0, size);
-    *code = closure;
-    return closure;
-}
-
-static void
-ffi_closure_free(void* ptr)
-{
-    munmap(ptr, sizeof(ffi_closure));
-}
-
-ffi_status
-ffi_prep_closure_loc(ffi_closure* closure, ffi_cif* cif,
-        void (*fun)(ffi_cif*, void*, void**, void*),
-        void* user_data, void* code)
-{
-    ffi_status retval = ffi_prep_closure(closure, cif, fun, user_data);
-    if (retval == FFI_OK) {
-        mprotect(closure, sizeof(ffi_closure), PROT_READ | PROT_EXEC);
-    }
-    return retval;
-}
-
-#endif /* HAVE_FFI_CLOSURE_ALLOC */
-
-void
-rbffi_Callback_Init(VALUE moduleFFI)
-{
-    rbffi_CallbackInfoClass = CallbackInfoClass = rb_define_class_under(moduleFFI, "CallbackInfo", rbffi_TypeClass);
-    rb_global_variable(&rbffi_CallbackInfoClass);
-
-    rb_define_alloc_func(CallbackInfoClass, cbinfo_allocate);
-    rb_define_method(CallbackInfoClass, "initialize", cbinfo_initialize, 2);
-
-    NativeCallbackClass = rb_define_class_under(moduleFFI, "NativeCallback", rb_cObject);
-    rb_global_variable(&NativeCallbackClass);
-    rb_define_alloc_func(NativeCallbackClass, native_callback_allocate);
-    id_call = rb_intern("call");
-    id_cbtable = rb_intern("@__ffi_callback_table__");
-}