ffi 0.5.0-x86-mingw32

data/ext/ffi_c/AbstractMemory.h

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2008, 2009, 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.
+ */
+
+#ifndef RBFFI_ABSTRACTMEMORY_H
+#define	RBFFI_ABSTRACTMEMORY_H
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdint.h>
+
+#include "compat.h"
+#include "Types.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+#define MEM_RD   0x01
+#define MEM_WR   0x02
+#define MEM_CODE 0x04
+
+typedef struct AbstractMemory_ AbstractMemory;
+
+typedef struct {
+    VALUE (*get)(AbstractMemory* ptr, long offset);
+    void (*put)(AbstractMemory* ptr, long offset, VALUE value);
+} MemoryOp;
+
+typedef struct {
+    MemoryOp* int8;
+    MemoryOp* uint8;
+    MemoryOp* int16;
+    MemoryOp* uint16;
+    MemoryOp* int32;
+    MemoryOp* uint32;
+    MemoryOp* int64;
+    MemoryOp* uint64;
+    MemoryOp* float32;
+    MemoryOp* float64;
+    MemoryOp* pointer;
+    MemoryOp* strptr;
+} MemoryOps;
+
+struct AbstractMemory_ {
+    char* address; // Use char* instead of void* to ensure adding to it works correctly
+    long size;
+    int access;
+    int typeSize;
+    MemoryOps* ops;
+};
+
+extern void rbffi_AbstractMemory_Init(VALUE ffiModule);
+
+extern AbstractMemory* rbffi_AbstractMemory_Cast(VALUE obj, VALUE klass);
+
+extern void rbffi_AbstractMemory_Error(AbstractMemory *, int op);
+
+static inline void
+checkBounds(AbstractMemory* mem, long off, long len)
+{
+    if (unlikely((off | len | (off + len) | (mem->size - (off + len))) < 0)) {
+        rb_raise(rb_eIndexError, "Memory access offset=%ld size=%ld is out of bounds",
+                off, len);
+    }
+}
+
+static inline void
+checkRead(AbstractMemory* mem)
+{
+    if (unlikely((mem->access & MEM_RD) == 0)) {
+        rbffi_AbstractMemory_Error(mem, MEM_RD);
+    }
+}
+
+static inline void
+checkWrite(AbstractMemory* mem)
+{
+    if (unlikely((mem->access & MEM_WR) == 0)) {
+        rbffi_AbstractMemory_Error(mem, MEM_WR);
+    }
+}
+
+static inline MemoryOp*
+memory_get_op(AbstractMemory* ptr, Type* type)
+{
+    if (ptr == NULL || ptr->ops == NULL || type == NULL) {
+        return NULL;
+    }
+    switch (type->nativeType) {
+        case NATIVE_INT8:
+            return ptr->ops->int8;
+        case NATIVE_UINT8:
+            return ptr->ops->uint8;
+        case NATIVE_INT16:
+            return ptr->ops->int16;
+        case NATIVE_UINT16:
+            return ptr->ops->uint16;
+        case NATIVE_INT32:
+            return ptr->ops->int32;
+        case NATIVE_UINT32:
+            return ptr->ops->uint32;
+        case NATIVE_INT64:
+            return ptr->ops->int64;
+        case NATIVE_UINT64:
+            return ptr->ops->uint64;
+        case NATIVE_FLOAT32:
+            return ptr->ops->float32;
+        case NATIVE_FLOAT64:
+            return ptr->ops->float64;
+        case NATIVE_POINTER:
+            return ptr->ops->pointer;
+        case NATIVE_STRING:
+            return ptr->ops->strptr;
+        default:
+            return NULL;
+    }
+}
+
+#define MEMORY(obj) rbffi_AbstractMemory_Cast((obj), rbffi_AbstractMemoryClass)
+#define MEMORY_PTR(obj) MEMORY((obj))->address
+#define MEMORY_LEN(obj) MEMORY((obj))->size
+
+
+
+extern VALUE rbffi_AbstractMemoryClass;
+extern MemoryOps rbffi_AbstractMemoryOps;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_ABSTRACTMEMORY_H */
+

data/ext/ffi_c/ArrayType.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2009, 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 "ArrayType.h"
+
+static VALUE array_type_s_allocate(VALUE klass);
+static VALUE array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength);
+static void array_type_mark(ArrayType *);
+static void array_type_free(ArrayType *);
+
+VALUE rbffi_ArrayTypeClass = Qnil;
+
+static VALUE
+array_type_s_allocate(VALUE klass)
+{
+    ArrayType* array;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, ArrayType, array_type_mark, array_type_free, array);
+
+    array->base.nativeType = NATIVE_ARRAY;
+    array->base.ffiType = xcalloc(1, sizeof(*array->base.ffiType));
+    array->base.ffiType->type = FFI_TYPE_STRUCT;
+    array->base.ffiType->size = 0;
+    array->base.ffiType->alignment = 0;
+    array->rbComponentType = Qnil;
+
+    return obj;
+}
+
+static void
+array_type_mark(ArrayType *array)
+{
+    rb_gc_mark(array->rbComponentType);
+}
+
+static void
+array_type_free(ArrayType *array)
+{
+    xfree(array->base.ffiType);
+    xfree(array->ffiTypes);
+    xfree(array);
+}
+
+
+static VALUE
+array_type_initialize(VALUE self, VALUE rbComponentType, VALUE rbLength)
+{
+    ArrayType* array;
+    int i;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    array->length = NUM2UINT(rbLength);
+    array->rbComponentType = rbComponentType;
+    Data_Get_Struct(rbComponentType, Type, array->componentType);
+    
+    array->ffiTypes = xcalloc(array->length + 1, sizeof(*array->ffiTypes));
+    array->base.ffiType->elements = array->ffiTypes;
+    array->base.ffiType->size = array->componentType->ffiType->size * array->length;
+    array->base.ffiType->alignment = array->componentType->ffiType->alignment;
+
+    for (i = 0; i < array->length; ++i) {
+        array->ffiTypes[i] = array->componentType->ffiType;
+    }
+
+    return self;
+}
+
+static VALUE
+array_type_length(VALUE self)
+{
+    ArrayType* array;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    return UINT2NUM(array->length);
+}
+
+static VALUE
+array_type_element_type(VALUE self)
+{
+    ArrayType* array;
+
+    Data_Get_Struct(self, ArrayType, array);
+
+    return array->rbComponentType;
+}
+
+void
+rbffi_ArrayType_Init(VALUE moduleFFI)
+{
+    rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", rbffi_TypeClass);
+    rb_global_variable(&rbffi_ArrayTypeClass);
+    rb_define_const(rbffi_TypeClass, "Array", rbffi_ArrayTypeClass);
+
+    rb_define_alloc_func(rbffi_ArrayTypeClass, array_type_s_allocate);
+    rb_define_method(rbffi_ArrayTypeClass, "initialize", array_type_initialize, 2);
+    rb_define_method(rbffi_ArrayTypeClass, "length", array_type_length, 0);
+    rb_define_method(rbffi_ArrayTypeClass, "elem_type", array_type_element_type, 0);
+}
+

data/ext/ffi_c/ArrayType.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2009, 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.
+ */
+
+#ifndef RBFFI_ARRAYTYPE_H
+#define	RBFFI_ARRAYTYPE_H
+
+#include <ruby.h>
+#include <ffi.h>
+#include "Type.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+
+typedef struct ArrayType_ {
+    Type base;
+    int length;
+    ffi_type** ffiTypes;
+    Type* componentType;
+    VALUE rbComponentType;
+} ArrayType;
+
+extern void rbffi_ArrayType_Init(VALUE moduleFFI);
+extern VALUE rbffi_ArrayTypeClass;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_ARRAYTYPE_H */
+

data/ext/ffi_c/AutoPointer.c

@@ -0,0 +1,61 @@
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "AutoPointer.h"
+
+typedef struct AutoPointer {
+    AbstractMemory memory;
+    VALUE parent;
+} AutoPointer;
+
+static void autoptr_mark(AutoPointer* ptr);
+static VALUE autoptr_allocate(VALUE klass);
+static VALUE autoptr_set_parent(VALUE self, VALUE parent);
+
+VALUE rbffi_AutoPointerClass = Qnil;
+
+static VALUE
+autoptr_allocate(VALUE klass)
+{
+    AutoPointer* p;
+    VALUE obj = Data_Make_Struct(klass, AutoPointer, autoptr_mark, -1, p);
+    p->parent = Qnil;
+    p->memory.ops = &rbffi_AbstractMemoryOps;
+    p->memory.access = MEM_RD | MEM_WR;
+
+    return obj;
+}
+
+static VALUE
+autoptr_set_parent(VALUE self, VALUE parent)
+{
+    AutoPointer* p;
+    AbstractMemory* ptr = rbffi_AbstractMemory_Cast(parent, rbffi_PointerClass);
+
+    Data_Get_Struct(self, AutoPointer, p);
+    p->memory = *ptr;
+    p->parent = parent;
+
+    return self;
+}
+
+static void
+autoptr_mark(AutoPointer* ptr)
+{
+    rb_gc_mark(ptr->parent);
+}
+
+void
+rbffi_AutoPointer_Init(VALUE moduleFFI)
+{
+    rbffi_AutoPointerClass = rb_define_class_under(moduleFFI, "AutoPointer", rbffi_PointerClass);
+    rb_global_variable(&rbffi_AutoPointerClass);
+    
+    rb_define_alloc_func(rbffi_AutoPointerClass, autoptr_allocate);
+    rb_define_protected_method(rbffi_AutoPointerClass, "parent=", autoptr_set_parent, 1);
+}

data/ext/ffi_c/AutoPointer.h

@@ -0,0 +1,18 @@
+
+#ifndef _AUTOPOINTER_H
+#define	_AUTOPOINTER_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+extern void rbffi_AutoPointer_Init(VALUE ffiModule);
+extern VALUE rbffi_AutoPointerClass;
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _AUTOPOINTER_H */
+

data/ext/ffi_c/Buffer.c

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2008, 2009, 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 <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+
+typedef struct Buffer {
+    AbstractMemory memory;
+    char* storage; /* start of malloc area */
+    VALUE rbParent;
+} Buffer;
+
+static VALUE buffer_allocate(VALUE klass);
+static VALUE buffer_initialize(int argc, VALUE* argv, VALUE self);
+static void buffer_release(Buffer* ptr);
+static void buffer_mark(Buffer* ptr);
+static VALUE buffer_free(VALUE self);
+
+static VALUE BufferClass = Qnil;
+
+static VALUE
+buffer_allocate(VALUE klass)
+{
+    Buffer* buffer;
+    VALUE obj;
+
+    obj = Data_Make_Struct(klass, Buffer, NULL, buffer_release, buffer);
+    buffer->rbParent = Qnil;
+    buffer->memory.ops = &rbffi_AbstractMemoryOps;
+    buffer->memory.access = MEM_RD | MEM_WR;
+
+    return obj;
+}
+
+static void
+buffer_release(Buffer* ptr)
+{
+    if (ptr->storage != NULL) {
+        xfree(ptr->storage);
+        ptr->storage = NULL;
+    }
+    
+    xfree(ptr);
+}
+
+static VALUE
+buffer_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rbSize = Qnil, rbCount = Qnil, rbClear = Qnil;
+    Buffer* p;
+    int nargs;
+
+    Data_Get_Struct(self, Buffer, p);
+
+    nargs = rb_scan_args(argc, argv, "12", &rbSize, &rbCount, &rbClear);
+    p->memory.typeSize = rbffi_type_size(rbSize);
+    p->memory.size = p->memory.typeSize * (nargs > 1 ? NUM2LONG(rbCount) : 1);
+
+    p->storage = xmalloc(p->memory.size + 7);
+    if (p->storage == NULL) {
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%lu bytes", p->memory.size);
+    }
+
+    /* ensure the memory is aligned on at least a 8 byte boundary */
+    p->memory.address = (void *) (((uintptr_t) p->storage + 0x7) & (uintptr_t) ~0x7UL);
+    
+    if (nargs > 2 && (RTEST(rbClear) || rbClear == Qnil) && p->memory.size > 0) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, self, buffer_free, self);
+    }
+
+    return self;
+}
+
+static VALUE
+buffer_alloc_inout(int argc, VALUE* argv, VALUE klass)
+{
+    return buffer_initialize(argc, argv, buffer_allocate(klass));
+}
+
+static VALUE
+buffer_plus(VALUE self, VALUE rbOffset)
+{
+    Buffer* ptr;
+    Buffer* result;
+    VALUE obj = Qnil;
+    long offset = NUM2LONG(rbOffset);
+
+    Data_Get_Struct(self, Buffer, ptr);
+    checkBounds(&ptr->memory, offset, 1);
+
+    obj = Data_Make_Struct(BufferClass, Buffer, buffer_mark, -1, result);
+    result->memory.address = ptr->memory.address + offset;
+    result->memory.size = ptr->memory.size - offset;
+    result->memory.ops = ptr->memory.ops;
+    result->memory.access = ptr->memory.access;
+    result->memory.typeSize = ptr->memory.typeSize;
+    result->rbParent = self;
+
+    return obj;
+}
+
+static VALUE
+buffer_inspect(VALUE self)
+{
+    char tmp[100];
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+
+    snprintf(tmp, sizeof(tmp), "#<FFI:Buffer:%p address=%p size=%ld>", ptr, ptr->memory.address, ptr->memory.size);
+    
+    return rb_str_new2(tmp);
+}
+
+/* Only used to free the buffer if the yield in the initializer throws an exception */
+static VALUE
+buffer_free(VALUE self)
+{
+    Buffer* ptr;
+
+    Data_Get_Struct(self, Buffer, ptr);
+    if (ptr->storage != NULL) {
+        free(ptr->storage);
+        ptr->storage = NULL;
+    }
+
+    return self;
+}
+
+static void
+buffer_mark(Buffer* ptr)
+{
+    rb_gc_mark(ptr->rbParent);
+}
+
+void
+rbffi_Buffer_Init(VALUE moduleFFI)
+{
+    BufferClass = rb_define_class_under(moduleFFI, "Buffer", rbffi_AbstractMemoryClass);
+
+    rb_global_variable(&BufferClass);
+    rb_define_alloc_func(BufferClass, buffer_allocate);
+
+    rb_define_singleton_method(BufferClass, "alloc_inout", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_out", buffer_alloc_inout, -1);
+    rb_define_singleton_method(BufferClass, "alloc_in", buffer_alloc_inout, -1);
+    rb_define_alias(rb_singleton_class(BufferClass), "new_in", "alloc_in");
+    rb_define_alias(rb_singleton_class(BufferClass), "new_out", "alloc_out");
+    rb_define_alias(rb_singleton_class(BufferClass), "new_inout", "alloc_inout");
+    
+    rb_define_method(BufferClass, "initialize", buffer_initialize, -1);
+    rb_define_method(BufferClass, "inspect", buffer_inspect, 0);
+    rb_define_alias(BufferClass, "length", "total");
+    rb_define_method(BufferClass, "+", buffer_plus, 1);
+}