ffi 1.0.2 → 1.0.3

data/ext/ffi_c/MethodHandle.c

@@ -1,28 +1,20 @@
 /*
- * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, 2010 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>
@@ -57,10 +49,6 @@
 
 #define MAX_METHOD_FIXED_ARITY (6)
 
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-#  define USE_PTHREAD_LOCAL
-#endif
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif

data/ext/ffi_c/Pointer.c

@@ -162,13 +162,19 @@ ptr_slice(VALUE self, VALUE rbOffset, VALUE rbLength)
 static VALUE
 ptr_inspect(VALUE self)
 {
+    char buf[100];
     Pointer* ptr;
     
     Data_Get_Struct(self, Pointer, ptr);
 
-    return ptr->memory.size != LONG_MAX
-        ? rb_sprintf("#<%s address=%p size=%lu>", rb_obj_classname(self), ptr->memory.address, ptr->memory.size)
-        : rb_sprintf("#<%s address=%p>", rb_obj_classname(self), ptr->memory.address);
+    if (ptr->memory.size != LONG_MAX) {
+        snprintf(buf, sizeof(buf), "#<%s address=%p size=%lu>",
+                rb_obj_classname(self), ptr->memory.address, ptr->memory.size);
+    } else {
+        snprintf(buf, sizeof(buf), "#<%s address=%p>", rb_obj_classname(self), ptr->memory.address);
+    }
+
+    return rb_str_new2(buf);
 }
 
 static VALUE

data/ext/ffi_c/Thread.c

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2010 Wayne Meissner
+ *
+ * All rights reserved.
+ *
+ * This file is part of ruby-ffi.
+ *
+ * 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 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 <stdbool.h>
+
+#ifndef _WIN32
+# include <pthread.h>
+# include <errno.h>
+#endif
+#include <fcntl.h>
+#include "Thread.h"
+
+
+#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
+rbffi_thread_t rbffi_active_thread;
+
+rbffi_thread_t
+rbffi_thread_self()
+{
+    rbffi_thread_t self;
+    self.id = pthread_self();
+    self.valid = true;
+
+    return self;
+}
+
+bool
+rbffi_thread_equal(rbffi_thread_t* lhs, rbffi_thread_t* rhs)
+{
+    return lhs->valid && rhs->valid && pthread_equal(lhs->id, rhs->id);
+}
+
+bool
+rbffi_thread_has_gvl_p(void)
+{
+    return rbffi_active_thread.valid && pthread_equal(rbffi_active_thread.id, pthread_self());
+}
+#endif // HAVE_RUBY_THREAD_HAS_GVL_P
+
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+struct BlockingThread {
+    pthread_t tid;
+    VALUE (*fn)(void *);
+    void *data;
+    void (*ubf)(void *);
+    void *data2;
+    VALUE retval;
+    int wrfd;
+    int rdfd;
+};
+
+typedef struct BlockingCall_ {
+    void* function;
+    void* info;
+    void **ffiValues;
+    void* retval;
+} BlockingCall;
+
+static void*
+rbffi_blocking_thread(void* args)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) args;
+    char c = 1;
+    VALUE retval;
+    
+    retval = (*thr->fn)(thr->data);
+    
+    pthread_testcancel();
+
+    thr->retval = retval;
+    
+    write(thr->wrfd, &c, sizeof(c));
+
+    return NULL;
+}
+
+static VALUE
+wait_for_thread(void *data)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) data;
+    char c;
+    
+    if (read(thr->rdfd, &c, 1) < 1) {
+        rb_thread_wait_fd(thr->rdfd);
+        while (read(thr->rdfd, &c, 1) < 1 && rb_io_wait_readable(thr->rdfd) == Qtrue) {
+            ;
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE
+cleanup_blocking_thread(void *data, VALUE exc)
+{
+    struct BlockingThread* thr = (struct BlockingThread *) data;
+
+    if (thr->ubf != (void (*)(void *)) -1) {
+        (*thr->ubf)(thr->data2);
+    } else {
+        pthread_kill(thr->tid, SIGVTALRM);
+    }
+
+    return exc;
+}
+
+VALUE
+rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(void *), void *data2)
+{
+    struct BlockingThread* thr;
+    int fd[2];
+    VALUE exc;
+    
+    if (pipe(fd) < 0) {
+        rb_raise(rb_eSystemCallError, "pipe(2) failed");
+        return Qnil;
+    }
+    fcntl(fd[0], F_SETFL, fcntl(fd[0], F_GETFL) | O_NONBLOCK);
+
+    thr = ALLOC_N(struct BlockingThread, 1);
+    thr->rdfd = fd[0];
+    thr->wrfd = fd[1];
+    thr->fn = func;
+    thr->data = data1;
+    thr->ubf = ubf;
+    thr->data2 = data2;
+    thr->retval = Qnil;
+
+    if (pthread_create(&thr->tid, NULL, rbffi_blocking_thread, thr) != 0) {
+        close(fd[0]);
+        close(fd[1]);
+        xfree(thr);
+        rb_raise(rb_eSystemCallError, "pipe(2) failed");
+        return Qnil;
+    }
+
+    exc = rb_rescue2(wait_for_thread, (VALUE) thr, cleanup_blocking_thread, (VALUE) thr,
+        rb_eException);
+    
+    pthread_join(thr->tid, NULL);
+    close(fd[1]);
+    close(fd[0]);
+    xfree(thr);
+
+    if (exc != Qnil) {
+        rb_exc_raise(exc);
+    }
+
+    return thr->retval;
+}
+
+#endif // HAVE_RB_THREAD_BLOCKING_REGION

data/ext/ffi_c/Thread.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2010 Wayne Meissner
+ *
+ * All rights reserved.
+ *
+ * This file is part of ruby-ffi.
+ *
+ * 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 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 THREAD_H
+#define	THREAD_H
+
+#include <stdbool.h>
+#include <ruby.h>
+#include "extconf.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+#ifdef HAVE_RUBY_THREAD_HAS_GVL_P
+# define rbffi_thread_has_gvl_p ruby_thread_has_gvl_p
+#else
+
+#include <pthread.h>
+
+typedef struct {
+    pthread_t id;
+    bool valid;
+} rbffi_thread_t;
+
+extern rbffi_thread_t rbffi_active_thread;
+rbffi_thread_t rbffi_thread_self();
+bool rbffi_thread_equal(rbffi_thread_t* lhs, rbffi_thread_t* rhs);
+bool rbffi_thread_has_gvl_p(void);
+
+#endif
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+# define rbffi_thread_blocking_region rb_thread_blocking_region
+#else
+
+VALUE rbffi_thread_blocking_region(VALUE (*func)(void *), void *data1, void (*ubf)(void *), void *data2);
+
+#endif
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* THREAD_H */
+

data/ext/ffi_c/Type.c

@@ -95,12 +95,15 @@ type_alignment(VALUE self)
 static VALUE
 type_inspect(VALUE self)
 {
+    char buf[100];
     Type *type;
 
     Data_Get_Struct(self, Type, type);
 
-    return rb_sprintf("#<%s:%p size=%d alignment=%d>",
+    snprintf(buf, sizeof(buf), "#<%s:%p size=%d alignment=%d>",
             rb_obj_classname(self), type, (int) type->ffiType->size, (int) type->ffiType->alignment);
+
+    return rb_str_new2(buf);
 }
 
 static VALUE
@@ -128,11 +131,14 @@ builtin_type_free(BuiltinType *type)
 static VALUE
 builtin_type_inspect(VALUE self)
 {
+    char buf[100];
     BuiltinType *type;
 
     Data_Get_Struct(self, BuiltinType, type);
-    return rb_sprintf("#<%s:%s size=%d alignment=%d>",
+    snprintf(buf, sizeof(buf), "#<%s:%s size=%d alignment=%d>",
             rb_obj_classname(self), type->name, (int) type->type.ffiType->size, type->type.ffiType->alignment);
+
+    return rb_str_new2(buf);
 }
 
 int

data/ext/ffi_c/Types.c

@@ -41,7 +41,7 @@ static ID id_from_native = 0;
 
 
 VALUE
-rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
+rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
 {
     switch (type->nativeType) {
         case NATIVE_VOID:
@@ -100,11 +100,10 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
         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;
+            MappedType* m = (MappedType *) type;
             VALUE values[2];
 
-            Data_Get_Struct(rbType, MappedType, m);
-            values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr, enums);
+            values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr);
             values[1] = Qnil;
 
             return rb_funcall2(m->rbConverter, id_from_native, 2, values);

data/ext/ffi_c/Types.h

@@ -76,7 +76,7 @@ typedef enum {
 #include <ffi.h>
 #include "Type.h"
 
-VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums);
+VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr);
 void rbffi_Types_Init(VALUE moduleFFI);
 
 #ifdef	__cplusplus

data/ext/ffi_c/Variadic.c

@@ -1,28 +1,20 @@
 /*
- * Copyright (c) 2008, 2009, Wayne Meissner
+ * Copyright (c) 2008-2010 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>
@@ -44,6 +36,7 @@
 #include "LastError.h"
 #include "MethodHandle.h"
 #include "Call.h"
+#include "Thread.h"
 
 typedef struct VariadicInvoker_ {
     VALUE rbAddress;
@@ -159,7 +152,9 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     VALUE* argv;
     int paramCount = 0, i;
     ffi_status ffiStatus;
-
+#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
+    rbffi_thread_t oldThread;
+#endif
     Check_Type(parameterTypes, T_ARRAY);
     Check_Type(parameterValues, T_ARRAY);
 
@@ -229,12 +224,20 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
 
     rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
         ffiValues, NULL, 0, invoker->rbEnums);
+#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
+    oldThread = rbffi_active_thread;
+    rbffi_active_thread = rbffi_thread_self();
+#endif
 
     ffi_call(&cif, invoker->function, retval, ffiValues);
 
+#ifndef HAVE_RUBY_THREAD_HAS_GVL_P
+    rbffi_active_thread = oldThread;
+#endif
+
     rbffi_save_errno();
 
-    return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval, invoker->rbEnums);
+    return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval);
 }