ffi 0.6.4 → 1.0.0

data/ext/ffi_c/MappedType.c

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 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:
+ *
+ * * 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 <ffi.h>
+#include "rbffi.h"
+
+#include "Type.h"
+#include "MappedType.h"
+
+
+static VALUE mapped_allocate(VALUE);
+static VALUE mapped_initialize(VALUE, VALUE);
+static void mapped_mark(MappedType *);
+static ID id_native_type, id_to_native, id_from_native;
+
+VALUE rbffi_MappedTypeClass = Qnil;
+
+static VALUE
+mapped_allocate(VALUE klass)
+{
+    MappedType* m;
+
+    VALUE obj = Data_Make_Struct(klass, MappedType, mapped_mark, -1, m);
+
+    m->rbConverter = Qnil;
+    m->rbType = Qnil;
+    m->type = NULL;
+    m->base.nativeType = NATIVE_MAPPED;
+    m->base.ffiType = &ffi_type_void;
+    
+    return obj;
+}
+
+static VALUE
+mapped_initialize(VALUE self, VALUE rbConverter)
+{
+    MappedType* m = NULL;
+    Type* t = NULL;
+    
+    if (!rb_respond_to(rbConverter, id_native_type)) {
+        rb_raise(rb_eNoMethodError, "native_type method not implemented");
+    }
+
+    if (!rb_respond_to(rbConverter, id_to_native)) {
+        rb_raise(rb_eNoMethodError, "to_native method not implemented");
+    }
+
+    if (!rb_respond_to(rbConverter, id_from_native)) {
+        rb_raise(rb_eNoMethodError, "from_native method not implemented");
+    }
+    
+    Data_Get_Struct(self, MappedType, m);
+    m->rbType = rb_funcall2(rbConverter, id_native_type, 0, NULL);
+    if (!(rb_obj_is_kind_of(m->rbType, rbffi_TypeClass))) {
+        rb_raise(rb_eTypeError, "native_type did not return instance of FFI::Type");
+    }
+
+    m->rbConverter = rbConverter;
+    Data_Get_Struct(m->rbType, Type, m->type);
+    m->base.ffiType = m->type->ffiType;
+    
+    return self;
+}
+
+static void
+mapped_mark(MappedType* m)
+{
+    rb_gc_mark(m->rbType);
+    rb_gc_mark(m->rbConverter);
+}
+
+static VALUE
+mapped_native_type(VALUE self)
+{
+    MappedType*m = NULL;
+    Data_Get_Struct(self, MappedType, m);
+
+    return m->rbType;
+}
+
+static VALUE
+mapped_to_native(int argc, VALUE* argv, VALUE self)
+{
+    MappedType*m = NULL;
+    
+    Data_Get_Struct(self, MappedType, m);
+    
+    return rb_funcall2(m->rbConverter, id_to_native, argc, argv);
+}
+
+static VALUE
+mapped_from_native(int argc, VALUE* argv, VALUE self)
+{
+    MappedType*m = NULL;
+    
+    Data_Get_Struct(self, MappedType, m);
+
+    return rb_funcall2(m->rbConverter, id_from_native, argc, argv);
+}
+
+void
+rbffi_MappedType_Init(VALUE moduleFFI)
+{
+    
+    rbffi_MappedTypeClass = rb_define_class_under(rbffi_TypeClass, "Mapped", rbffi_TypeClass);
+    
+    rb_global_variable(&rbffi_MappedTypeClass);
+
+    id_native_type = rb_intern("native_type");
+    id_to_native = rb_intern("to_native");
+    id_from_native = rb_intern("from_native");
+
+    rb_define_alloc_func(rbffi_MappedTypeClass, mapped_allocate);
+    rb_define_method(rbffi_MappedTypeClass, "initialize", mapped_initialize, 1);
+    rb_define_method(rbffi_MappedTypeClass, "type", mapped_native_type, 0);
+    rb_define_method(rbffi_MappedTypeClass, "native_type", mapped_native_type, 0);
+    rb_define_method(rbffi_MappedTypeClass, "to_native", mapped_to_native, -1);
+    rb_define_method(rbffi_MappedTypeClass, "from_native", mapped_from_native, -1);
+}
+

data/{libtest/FunctionTest.c → ext/ffi_c/MappedType.h}

@@ -1,17 +1,17 @@
 /*
- * Copyright (c) 2009 Wayne Meissner. All rights reserved.
- * 
+ * Copyright (c) 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:
  *
- * 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.
- * Neither the name of the project nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
+ * * 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
@@ -25,26 +25,33 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <unistd.h>
+#ifndef RBFFI_MAPPEDTYPE_H
+#define	RBFFI_MAPPEDTYPE_H
+
+
+#include <ruby.h>
 
-#ifdef __WIN32__
-#include <windows.h>
-#define sleep(x) Sleep(x)
+#ifdef	__cplusplus
+extern "C" {
 #endif
 
-int testAdd(int a, int b)
-{
-    return a + b;
-};
 
-int testFunctionAdd(int a, int b, int (*f)(int, int))
-{
-    return f(a, b);
-};
+typedef struct MappedType_ {
+    Type base;
+    Type* type;
+    VALUE rbConverter;
+    VALUE rbType;
+    
+} MappedType;
 
-void testBlocking(int seconds) {
-    sleep(seconds);
-};
+void rbffi_MappedType_Init(VALUE moduleFFI);
 
+extern VALUE rbffi_MappedTypeClass;
+
+
+#ifdef	__cplusplus
+}
+#endif
 
+#endif	/* RBFFI_MAPPEDTYPE_H */
 

data/ext/ffi_c/MemoryPointer.c

@@ -4,27 +4,19 @@
  *
  * 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 <stdbool.h>
@@ -63,7 +55,7 @@ memptr_allocate(VALUE klass)
 {
     MemoryPointer* p;
     VALUE obj = Data_Make_Struct(klass, MemoryPointer, NULL, memptr_release, p);
-    p->memory.access = MEM_RD | MEM_WR;
+    p->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -113,18 +105,6 @@ memptr_malloc(VALUE self, long size, long count, bool clear)
     return self;
 }
 
-static VALUE
-memptr_inspect(VALUE self)
-{
-    MemoryPointer* ptr;
-    char tmp[100];
-
-    Data_Get_Struct(self, MemoryPointer, ptr);
-
-    snprintf(tmp, sizeof(tmp), "#<FFI::MemoryPointer address=%p size=%lu>", ptr->memory.address, ptr->memory.size);
-    return rb_str_new2(tmp);
-}
-
 static VALUE
 memptr_free(VALUE self)
 {
@@ -172,7 +152,6 @@ rbffi_MemoryPointer_Init(VALUE moduleFFI)
 
     rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate);
     rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1);
-    rb_define_method(rbffi_MemoryPointerClass, "inspect", memptr_inspect, 0);
     rb_define_method(rbffi_MemoryPointerClass, "autorelease=", memptr_autorelease, 1);
     rb_define_method(rbffi_MemoryPointerClass, "free", memptr_free, 0);
 }

data/ext/ffi_c/Platform.c

@@ -24,6 +24,8 @@ static VALUE PlatformModule = Qnil;
 #define CPU "sparc"
 #elif defined(__sparcv9__)
 #define CPU "sparcv9"
+#elif defined(__arm__)
+#define CPU "arm"
 #else
 #error "Unknown cpu type"
 #endif

data/ext/ffi_c/Pointer.c

@@ -3,27 +3,19 @@
  *
  * 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 <stdbool.h>
@@ -59,7 +51,7 @@ rbffi_Pointer_NewInstance(void* addr)
     obj = Data_Make_Struct(rbffi_PointerClass, Pointer, NULL, -1, p);
     p->memory.address = addr;
     p->memory.size = LONG_MAX;
-    p->memory.access = (addr == NULL) ? 0 : (MEM_RD | MEM_WR);
+    p->memory.flags = (addr == NULL) ? 0 : (MEM_RD | MEM_WR);
     p->memory.typeSize = 1;
     p->parent = Qnil;
 
@@ -72,9 +64,9 @@ ptr_allocate(VALUE klass)
     Pointer* p;
     VALUE obj;
 
-    obj = Data_Make_Struct(klass, Pointer, NULL, -1, p);
+    obj = Data_Make_Struct(klass, Pointer, ptr_mark, -1, p);
     p->parent = Qnil;
-    p->memory.access = MEM_RD | MEM_WR;
+    p->memory.flags = MEM_RD | MEM_WR;
 
     return obj;
 }
@@ -106,7 +98,7 @@ ptr_initialize(int argc, VALUE* argv, VALUE self)
             p->memory.address = (void*) (uintptr_t) NUM2LL(rbAddress);
             p->memory.size = LONG_MAX;
             if (p->memory.address == NULL) {
-                p->memory.access = 0;
+                p->memory.flags = 0;
             }
             break;
 
@@ -143,7 +135,7 @@ slice(VALUE self, long offset, long size)
 
     p->memory.address = ptr->address + offset;
     p->memory.size = size;
-    p->memory.access = ptr->access;
+    p->memory.flags = ptr->flags;
     p->memory.typeSize = ptr->typeSize;
     p->parent = self;
 
@@ -171,12 +163,12 @@ static VALUE
 ptr_inspect(VALUE self)
 {
     Pointer* ptr;
-    char tmp[100];
-
+    
     Data_Get_Struct(self, Pointer, ptr);
-    snprintf(tmp, sizeof(tmp), "#<FFI::Pointer address=%p>", ptr->memory.address);
 
-    return rb_str_new2(tmp);
+    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);
 }
 
 static VALUE
@@ -209,6 +201,50 @@ ptr_address(VALUE self)
     return ULL2NUM((uintptr_t) ptr->memory.address);
 }
 
+#if BYTE_ORDER == LITTLE_ENDIAN
+# define SWAPPED_ORDER BIG_ENDIAN
+#else
+# define SWAPPED_ORDER LITTLE_ENDIAN
+#endif
+
+static VALUE
+ptr_order(int argc, VALUE* argv, VALUE self)
+{
+    Pointer* ptr;
+
+    Data_Get_Struct(self, Pointer, ptr);
+    if (argc == 0) {
+        int order = (ptr->memory.flags & MEM_SWAP) == 0 ? BYTE_ORDER : SWAPPED_ORDER;
+        return order == BIG_ENDIAN ? ID2SYM(rb_intern("big")) : ID2SYM(rb_intern("little"));
+    } else {
+        VALUE rbOrder = Qnil;
+        int order = BYTE_ORDER;
+
+        if (rb_scan_args(argc, argv, "1", &rbOrder) < 1) {
+            rb_raise(rb_eArgError, "need byte order");
+        }
+        if (SYMBOL_P(rbOrder)) {
+            ID id = SYM2ID(rbOrder);
+            if (id == rb_intern("little")) {
+                order = LITTLE_ENDIAN;
+
+            } else if (id == rb_intern("big") || id == rb_intern("network")) {
+                order = BIG_ENDIAN;
+            }
+        }
+        if (order != BYTE_ORDER) {
+            Pointer* p2;
+            VALUE retval = slice(self, 0, ptr->memory.size);
+
+            Data_Get_Struct(retval, Pointer, p2);
+            p2->memory.flags |= MEM_SWAP;
+            return retval;
+        }
+
+        return self;
+    }
+}
+
 static void
 ptr_mark(Pointer* ptr)
 {
@@ -226,12 +262,14 @@ rbffi_Pointer_Init(VALUE moduleFFI)
     rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
     rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
     rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
+    rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0);
     rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
     rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2);
     rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
     rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
     rb_define_alias(rbffi_PointerClass, "to_i", "address");
     rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
+    rb_define_method(rbffi_PointerClass, "order", ptr_order, -1);
 
     rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
     rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);