ffi 0.1.0

data/ext/MemoryPointer.c

@@ -0,0 +1,164 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <ruby.h>
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "MemoryPointer.h"
+
+typedef struct MemoryPointer {
+    AbstractMemory memory;
+    VALUE parent;
+    bool autorelease;
+    bool allocated;
+} MemoryPointer;
+
+static VALUE memptr_allocate(VALUE self, VALUE size, VALUE count, VALUE clear);
+static void memptr_release(MemoryPointer* ptr);
+static void memptr_mark(MemoryPointer* ptr);
+
+VALUE rb_FFI_MemoryPointer_class;
+static VALUE classMemoryPointer = Qnil;
+
+VALUE
+rb_FFI_MemoryPointer_new(caddr_t addr)
+{
+    MemoryPointer* p;
+    
+    p = ALLOC(MemoryPointer);
+    memset(p, 0, sizeof(*p));
+    p->memory.address = addr;
+    p->memory.size = LONG_MAX;
+    p->parent = Qnil;
+    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
+}
+
+static VALUE
+memptr_allocate(VALUE self, VALUE size, VALUE count, VALUE clear)
+{
+    MemoryPointer* p;
+    
+    p = ALLOC(MemoryPointer);
+    memset(p, 0, sizeof(*p));
+    p->autorelease = true;
+    p->memory.size = NUM2LONG(size) * (count == Qnil ? 1 : NUM2LONG(count));
+    p->memory.address = p->memory.size > 0 ? malloc(p->memory.size) : NULL;
+    p->parent = Qnil;
+    p->allocated = true;
+
+    if (p->memory.address == NULL) {
+        long size = p->memory.size;
+        xfree(p);
+        rb_raise(rb_eNoMemError, "Failed to allocate memory size=%ld bytes", size);
+    }
+    if (TYPE(clear) == T_TRUE) {
+        memset(p->memory.address, 0, p->memory.size);
+    }
+    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
+}
+
+static VALUE
+memptr_plus(VALUE self, VALUE offset)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
+    MemoryPointer* p;
+    long off = NUM2LONG(offset);
+
+    checkBounds(&ptr->memory, off, 1);
+    p = ALLOC(MemoryPointer);
+    memset(p, 0, sizeof(*p));
+    p->memory.address = ptr->memory.address + off;;
+    p->memory.size = ptr->memory.size - off;;
+    p->parent = self;
+    p->allocated = false;
+    p->autorelease = true;
+    return Data_Wrap_Struct(classMemoryPointer, memptr_mark, memptr_release, p);
+}
+
+static VALUE
+memptr_inspect(VALUE self)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
+    char tmp[100];
+    snprintf(tmp, sizeof(tmp), "#<MemoryPointer address=%p>", ptr->memory.address);
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+memptr_null_p(VALUE self)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
+    return ptr->memory.address == NULL ? Qtrue : Qfalse;
+}
+
+static VALUE
+memptr_equals(VALUE self, VALUE other)
+{
+    MemoryPointer* p1 = (MemoryPointer *) DATA_PTR(self);
+    MemoryPointer* p2;
+    
+    if (!rb_obj_is_kind_of(other, classMemoryPointer)) {
+        rb_raise(rb_eArgError, "Comparing MemoryPointer with non MemoryPointer");
+    }
+    p2 = (MemoryPointer *) DATA_PTR(other);
+    return p1->memory.address == p2->memory.address ? Qtrue : Qfalse;
+}
+
+static VALUE
+memptr_free(VALUE self)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
+    if (ptr->allocated) {
+        free(ptr->memory.address);
+        ptr->memory.address = NULL;
+        ptr->allocated = false;
+    }
+    return self;
+}
+
+static VALUE
+memptr_autorelease(VALUE self, VALUE autorelease)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);
+    ptr->autorelease = autorelease == Qtrue;
+    return self;
+}
+
+static VALUE
+memptr_address(VALUE self)
+{
+    MemoryPointer* ptr = (MemoryPointer *) DATA_PTR(self);    
+    return ULL2NUM((uintptr_t) ptr->memory.address);
+}
+
+static void
+memptr_release(MemoryPointer* ptr)
+{
+    if (ptr->autorelease && ptr->allocated) {
+        free(ptr->memory.address);
+    }
+    xfree(ptr);
+
+}
+static void
+memptr_mark(MemoryPointer* ptr)
+{
+    if (ptr->parent != Qnil) {
+        rb_gc_mark(ptr->parent);
+    }
+}
+
+void
+rb_FFI_MemoryPointer_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    rb_FFI_MemoryPointer_class = classMemoryPointer = rb_define_class_under(moduleFFI, "MemoryPointer", rb_FFI_AbstractMemory_class);
+    rb_define_singleton_method(classMemoryPointer, "__allocate", memptr_allocate, 3);
+    rb_define_method(classMemoryPointer, "inspect", memptr_inspect, 0);
+    rb_define_method(classMemoryPointer, "+", memptr_plus, 1);
+    rb_define_method(classMemoryPointer, "null?", memptr_null_p, 0);
+    rb_define_method(classMemoryPointer, "autorelease=", memptr_autorelease, 1);
+    rb_define_method(classMemoryPointer, "free", memptr_free, 0);
+    rb_define_method(classMemoryPointer, "address", memptr_address, 0);
+    rb_define_method(classMemoryPointer, "==", memptr_equals, 1);
+}

data/ext/MemoryPointer.h

@@ -0,0 +1,25 @@
+/* 
+ * File:   MemoryPointer.h
+ * Author: wayne
+ *
+ * Created on August 28, 2008, 5:24 PM
+ */
+
+#ifndef _MEMORYPOINTER_H
+#define	_MEMORYPOINTER_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    extern void rb_FFI_MemoryPointer_Init();
+    extern VALUE rb_FFI_MemoryPointer_new(caddr_t addr);
+    extern VALUE rb_FFI_MemoryPointer_class;
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _MEMORYPOINTER_H */
+

data/ext/Platform.c

@@ -0,0 +1,41 @@
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include <ctype.h>
+#include "Platform.h"
+
+static VALUE modulePlatform = Qnil;
+
+/*
+ * Determine the cpu type at compile time - useful for MacOSX where the the
+ * system installed ruby incorrectly reports 'host_cpu' as 'powerpc' when running
+ * on intel.
+ */
+#ifdef __i386__
+#define CPU "i386"
+#elif defined(__ppc__) || defined(__powerpc__)
+#define CPU "powerpc"
+#elif defined(__x86_64__)
+#define CPU "x86_64"
+#elif defined(__sparc__)
+#define CPU "sparc"
+#elif defined(__sparcv9__)
+#define CPU "sparcv9"
+#else
+#error "Unknown cpu type"
+#endif
+
+void
+rb_FFI_Platform_Init()
+{
+    VALUE moduleFFI = rb_define_module("FFI");
+    VALUE platform = rb_define_module_under(moduleFFI, "Platform");
+    rb_define_const(platform, "LONG_SIZE", INT2FIX(sizeof(long) * 8));
+    rb_define_const(platform, "ADDRESS_SIZE", INT2FIX(sizeof(void *) * 8));
+    rb_define_const(platform, "BYTE_ORDER", INT2FIX(BYTE_ORDER));
+    rb_define_const(platform, "LITTLE_ENDIAN", INT2FIX(LITTLE_ENDIAN));
+    rb_define_const(platform, "BIG_ENDIAN", INT2FIX(BIG_ENDIAN));
+    rb_define_const(platform, "CPU", rb_str_new2(CPU));
+    modulePlatform = platform;
+}

data/ext/Platform.h

@@ -0,0 +1,23 @@
+/* 
+ * File:   Platform.h
+ * Author: wayne
+ *
+ * Created on August 29, 2008, 2:09 PM
+ */
+
+#ifndef _PLATFORM_H
+#define	_PLATFORM_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    extern void rb_FFI_Platform_Init();
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _PLATFORM_H */
+

data/ext/Types.c

@@ -0,0 +1,65 @@
+#include <ruby.h>
+#include "MemoryPointer.h"
+#include "Types.h"
+
+ffi_type*
+rb_FFI_NativeTypeToFFI(NativeType type)
+{
+    switch (type) {
+        case VOID:
+            return &ffi_type_void;
+        case INT8:
+            return &ffi_type_sint8;
+        case UINT8:
+            return &ffi_type_uint8;
+        case INT32:
+            return &ffi_type_sint32;
+        case UINT32:
+            return &ffi_type_uint32;
+        case INT64:
+            return &ffi_type_sint64;
+        case UINT64:
+            return &ffi_type_uint64;
+        case FLOAT32:
+            return &ffi_type_float;
+        case FLOAT64:
+            return &ffi_type_double;
+        case STRING:
+        case RBXSTRING:
+        case POINTER:
+            return &ffi_type_pointer;
+        default:
+            return NULL;
+    }
+}
+
+VALUE
+rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
+{
+    switch (type) {
+        case VOID:
+            return Qnil;        
+        case INT8:
+        case INT16:
+        case INT32:
+            return INT2FIX(*(int *) ptr);
+        case UINT8:
+        case UINT16:
+        case UINT32:
+            return INT2FIX(*(unsigned int *) ptr);
+        case INT64:
+            return LL2NUM(*(signed long long *) ptr);
+        case UINT64:
+            return ULL2NUM(*(unsigned long long *) ptr);
+        case FLOAT32:
+            return rb_float_new(*(float *) ptr);
+        case FLOAT64:
+            return rb_float_new(*(double *) ptr);
+        case STRING:
+            return rb_str_new2(*(char **) ptr);
+        case POINTER:
+            return rb_FFI_MemoryPointer_new(*(void **) ptr);
+        default:
+            rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
+    }
+}

data/ext/Types.h

@@ -0,0 +1,51 @@
+/* 
+ * File:   Types.h
+ * Author: wayne
+ *
+ * Created on September 9, 2008, 9:47 PM
+ */
+
+#ifndef _TYPES_H
+#define	_TYPES_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+    
+typedef enum {
+    VOID,
+    INT8,
+    UINT8,
+    INT16,
+    UINT16,
+    INT32,
+    UINT32,
+    INT64,
+    UINT64,
+    FLOAT32,
+    FLOAT64,
+    POINTER,
+    CALLBACK,
+    BUFFER_IN,
+    BUFFER_OUT,
+    BUFFER_INOUT,
+    CHAR_ARRAY,
+    
+    /**
+     * An immutable string.  Nul terminated, but only copies in to the native function
+     */
+    STRING,
+    /** A Rubinus :string arg - copies data both ways, and nul terminates */
+    RBXSTRING
+} NativeType;
+
+#include <ffi.h>
+extern ffi_type* rb_FFI_NativeTypeToFFI(NativeType type);
+VALUE rb_FFI_NativeValueToRuby(NativeType type, const void* ptr);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _TYPES_H */
+

data/ext/extconf.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+require 'rbconfig'
+dir_config("ffi_c")
+create_makefile("ffi_c")
+File.open("Makefile", "a") do |mf|
+  mf.puts "include $(srcdir)/ffi.mk"
+  if Config::CONFIG['host_os'] =~ /darwin/
+    mf.puts "include $(srcdir)/libffi.darwin.mk"
+  else
+    mf.puts "include $(srcdir)/libffi.mk"
+  end
+end

data/ext/ffi.c

@@ -0,0 +1,54 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <dlfcn.h>
+#include <ruby.h>
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "MemoryPointer.h"
+#include "Platform.h"
+#include "Types.h"
+
+
+void Init_ffi();
+
+static VALUE moduleFFI = Qnil;
+static VALUE moduleNativeType = Qnil;
+
+void
+Init_ffi_c() {
+    moduleFFI = rb_define_module("FFI");
+    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
+    
+    rb_define_const(moduleNativeType, "VOID", INT2FIX(VOID));
+    rb_define_const(moduleNativeType, "INT8", INT2FIX(INT8));
+    rb_define_const(moduleNativeType, "UINT8", INT2FIX(UINT8));
+    rb_define_const(moduleNativeType, "INT16", INT2FIX(INT16));
+    rb_define_const(moduleNativeType, "UINT16", INT2FIX(UINT16));
+    rb_define_const(moduleNativeType, "INT32", INT2FIX(INT32));
+    rb_define_const(moduleNativeType, "UINT32", INT2FIX(UINT32));
+    rb_define_const(moduleNativeType, "INT64", INT2FIX(INT64));
+    rb_define_const(moduleNativeType, "UINT64", INT2FIX(UINT64));
+    rb_define_const(moduleNativeType, "FLOAT32", INT2FIX(FLOAT32));
+    rb_define_const(moduleNativeType, "FLOAT64", INT2FIX(FLOAT64));
+    rb_define_const(moduleNativeType, "POINTER", INT2FIX(POINTER));
+    rb_define_const(moduleNativeType, "STRING", INT2FIX(STRING));
+    rb_define_const(moduleNativeType, "RBXSTRING", INT2FIX(RBXSTRING));
+    rb_define_const(moduleNativeType, "CHAR_ARRAY", INT2FIX(CHAR_ARRAY));
+    if (sizeof(long) == 4) {
+        rb_define_const(moduleNativeType, "LONG", INT2FIX(INT32));
+        rb_define_const(moduleNativeType, "ULONG", INT2FIX(UINT32));
+    } else {
+        rb_define_const(moduleNativeType, "LONG", INT2FIX(INT64));
+        rb_define_const(moduleNativeType, "ULONG", INT2FIX(UINT64));
+    }
+    rb_FFI_Platform_Init();
+    rb_FFI_AbstractMemory_Init();
+    rb_FFI_MemoryPointer_Init();
+    rb_FFI_Buffer_Init();
+    rb_FFI_Callback_Init();
+    rb_FFI_Invoker_Init();    
+}
+

data/ext/ffi.mk

@@ -0,0 +1,24 @@
+# -*- makefile -*-
+
+CFLAGS += -Werror
+LIBS += -lpthread
+INCFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
+LOCAL_LIBS += $(LIBFFI)
+
+FFI_MMAP_EXEC = -DFFI_MMAP_EXEC_WRIT
+FFI_CFLAGS = $(FFI_MMAP_EXEC) $(OFLAGS)
+BUILD_DIR = $(PWD)/build
+LIBFFI_SRC_DIR = $(PWD)/$(srcdir)/libffi
+LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
+LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a
+FFI_CONFIGURE = sh $(LIBFFI_SRC_DIR)/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	$(LIBFFI)
+
+clean:	libffi_clean
+
+libffi_clean::
+	$(RM) -r $(BUILD_DIR)
+
+