ffi 0.2.0 → 0.3.0

data/ext/ffi_c/Struct.h

@@ -0,0 +1,26 @@
+#ifndef _STRUCT_H
+#define	_STRUCT_H
+
+#include "AbstractMemory.h"
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    void rb_FFI_Struct_Init();
+
+    struct StructLayout;
+    typedef struct Struct {
+        struct StructLayout* layout;
+        AbstractMemory* pointer;
+        VALUE rbLayout;
+        VALUE rbPointer;
+    } Struct;
+
+    extern VALUE rb_FFI_Struct_class;
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _STRUCT_H */
+

data/ext/ffi_c/Types.c

@@ -0,0 +1,76 @@
+#include <ruby.h>
+#include "Pointer.h"
+#include "Types.h"
+
+ffi_type*
+rb_FFI_NativeTypeToFFI(NativeType type)
+{
+    switch (type) {
+        case NATIVE_VOID:
+            return &ffi_type_void;
+        case NATIVE_INT8:
+            return &ffi_type_sint8;
+        case NATIVE_UINT8:
+            return &ffi_type_uint8;
+        case NATIVE_INT16:
+            return &ffi_type_sint16;
+        case NATIVE_UINT16:
+            return &ffi_type_uint16;
+        case NATIVE_INT32:
+            return &ffi_type_sint32;
+        case NATIVE_UINT32:
+            return &ffi_type_uint32;
+        case NATIVE_INT64:
+            return &ffi_type_sint64;
+        case NATIVE_UINT64:
+            return &ffi_type_uint64;
+        case NATIVE_FLOAT32:
+            return &ffi_type_float;
+        case NATIVE_FLOAT64:
+            return &ffi_type_double;
+        case NATIVE_STRING:
+        case NATIVE_RBXSTRING:
+        case NATIVE_POINTER:
+        case NATIVE_BUFFER_IN:
+        case NATIVE_BUFFER_OUT:
+        case NATIVE_BUFFER_INOUT:
+            return &ffi_type_pointer;
+        default:
+            return NULL;
+    }
+}
+
+VALUE
+rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
+{
+    switch (type) {
+        case NATIVE_VOID:
+            return Qnil;
+        case NATIVE_INT8:
+          return INT2NUM((signed char) *(ffi_sarg *) ptr);
+        case NATIVE_INT16:
+          return INT2NUM((signed short) *(ffi_sarg *) ptr);
+        case NATIVE_INT32:
+          return INT2NUM((signed int) *(ffi_sarg *) ptr);
+        case NATIVE_UINT8:
+          return UINT2NUM((unsigned char) *(ffi_arg *) ptr);
+        case NATIVE_UINT16:
+          return UINT2NUM((unsigned short) *(ffi_arg *) ptr);
+        case NATIVE_UINT32:
+          return UINT2NUM((unsigned int) *(ffi_arg *) ptr);
+        case NATIVE_INT64:
+            return LL2NUM(*(signed long long *) ptr);
+        case NATIVE_UINT64:
+            return ULL2NUM(*(unsigned long long *) ptr);
+        case NATIVE_FLOAT32:
+            return rb_float_new(*(float *) ptr);
+        case NATIVE_FLOAT64:
+            return rb_float_new(*(double *) ptr);
+        case NATIVE_STRING:
+            return rb_tainted_str_new2(*(char **) ptr);
+        case NATIVE_POINTER:
+            return rb_FFI_Pointer_new(*(void **) ptr);
+        default:
+            rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
+    }
+}

data/ext/{Types.h → ffi_c/Types.h}

@@ -1,44 +1,39 @@
-/* 
- * File:   Types.h
- * Author: wayne
- *
- * Created on September 9, 2008, 9:47 PM
- */
-
 #ifndef _TYPES_H
 #define	_TYPES_H
 
 #ifdef	__cplusplus
 extern "C" {
 #endif
-    
+#ifdef VOID
+#  undef VOID
+#endif
 typedef enum {
-    VOID,
-    INT8,
-    UINT8,
-    INT16,
-    UINT16,
-    INT32,
-    UINT32,
-    INT64,
-    UINT64,
-    FLOAT32,
-    FLOAT64,
-    POINTER,
-    CALLBACK,
-    BUFFER_IN,
-    BUFFER_OUT,
-    BUFFER_INOUT,
-    CHAR_ARRAY,
+    NATIVE_VOID,
+    NATIVE_INT8,
+    NATIVE_UINT8,
+    NATIVE_INT16,
+    NATIVE_UINT16,
+    NATIVE_INT32,
+    NATIVE_UINT32,
+    NATIVE_INT64,
+    NATIVE_UINT64,
+    NATIVE_FLOAT32,
+    NATIVE_FLOAT64,
+    NATIVE_POINTER,
+    NATIVE_CALLBACK,
+    NATIVE_BUFFER_IN,
+    NATIVE_BUFFER_OUT,
+    NATIVE_BUFFER_INOUT,
+    NATIVE_CHAR_ARRAY,
     
     /**
      * An immutable string.  Nul terminated, but only copies in to the native function
      */
-    STRING,
+    NATIVE_STRING,
     /** A Rubinus :string arg - copies data both ways, and nul terminates */
-    RBXSTRING,
+    NATIVE_RBXSTRING,
     /** The function takes a variable number of arguments */
-    VARARGS,
+    NATIVE_VARARGS,
 } NativeType;
 
 #include <ffi.h>

data/ext/{compat.h → ffi_c/compat.h}

@@ -6,8 +6,8 @@
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(ary) RARRAY(ary)->len
 #endif
-#ifndef RSTRING_LEN
-#  define RSTRING_LEN(s) RSTRING(s)->len
+#ifndef RARRAY_PTR
+#  define RARRAY_PTR(ary) RARRAY(ary)->ptr
 #endif
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s) RSTRING(s)->len

data/ext/{extconf.rb → ffi_c/extconf.rb}

@@ -2,7 +2,7 @@
 require 'mkmf'
 require 'rbconfig'
 dir_config("ffi_c")
-IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
+#IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
 #if IS_MAC
 #  $CPPFLAGS << " -DMACOSX"
 #  find_header("ffi.h", "/usr/include/ffi")
@@ -16,10 +16,15 @@ $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
 create_makefile("ffi_c")
 create_header("extconf.h")
 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"
+  mf.puts "CPPFLAGS += -Werror -Wunused -Wformat"
+  unless libffi_ok 
+    mf.puts "include $(srcdir)/ffi.mk"
+    mf.puts "LIBFFI_HOST=--host=#{Config::CONFIG['host_alias']}" if Config::CONFIG.has_key?("host_alias")
+    mf.puts "FFI_MMAP_EXEC=-DFFI_MMAP_EXEC_WRIT=#{Config::CONFIG['host_os'] =~ /win/ ? 0 : 1}"
+    if Config::CONFIG['host_os'] =~ /darwin/
+      mf.puts "include $(srcdir)/libffi.darwin.mk"
+    else
+      mf.puts "include $(srcdir)/libffi.mk"
+    end
   end
-end unless libffi_ok
+end

data/ext/ffi_c/ffi.c

@@ -0,0 +1,99 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <ruby.h>
+
+#include <ffi.h>
+
+#include "rbffi.h"
+#include "AbstractMemory.h"
+#include "Pointer.h"
+#include "MemoryPointer.h"
+#include "AutoPointer.h"
+#include "Struct.h"
+#include "NativeLibrary.h"
+#include "Platform.h"
+#include "Types.h"
+
+
+void Init_ffi_c();
+
+static VALUE moduleFFI = Qnil;
+static VALUE moduleNativeType = Qnil;
+static VALUE typeMap = Qnil, sizeMap = Qnil;
+static ID type_size_id = 0, size_id;
+
+int
+rb_FFI_type_size(VALUE type)
+{
+    int t = TYPE(type);
+    if (t == T_FIXNUM || t == T_BIGNUM) {
+        return NUM2INT(type);
+    } else if (t == T_SYMBOL) {
+        /*
+         * Try looking up directly in the type and size maps
+         */
+        VALUE nType;
+        if ((nType = rb_hash_aref(typeMap, type)) != Qnil) {
+            VALUE nSize = rb_hash_aref(sizeMap, nType);
+            if (TYPE(nSize) == T_FIXNUM) {
+                return FIX2INT(nSize);
+            }
+        }
+        // Not found - call up to the ruby version to resolve
+        return rb_funcall(moduleFFI, rb_intern("type_size"), 1, &type);
+    } else {
+        return rb_funcall(type, size_id, 0, NULL);
+    }
+}
+
+void
+Init_ffi_c() {
+    moduleFFI = rb_define_module("FFI");
+    rb_global_variable(&moduleFFI);
+    moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
+    rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
+    rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
+    rb_global_variable(&typeMap);
+    rb_global_variable(&sizeMap);
+    type_size_id = rb_intern("type_size");
+    size_id = rb_intern("size");
+    
+    rb_define_const(moduleNativeType, "VOID", INT2FIX(NATIVE_VOID));
+    rb_define_const(moduleNativeType, "INT8", INT2FIX(NATIVE_INT8));
+    rb_define_const(moduleNativeType, "UINT8", INT2FIX(NATIVE_UINT8));
+    rb_define_const(moduleNativeType, "INT16", INT2FIX(NATIVE_INT16));
+    rb_define_const(moduleNativeType, "UINT16", INT2FIX(NATIVE_UINT16));
+    rb_define_const(moduleNativeType, "INT32", INT2FIX(NATIVE_INT32));
+    rb_define_const(moduleNativeType, "UINT32", INT2FIX(NATIVE_UINT32));
+    rb_define_const(moduleNativeType, "INT64", INT2FIX(NATIVE_INT64));
+    rb_define_const(moduleNativeType, "UINT64", INT2FIX(NATIVE_UINT64));
+    rb_define_const(moduleNativeType, "FLOAT32", INT2FIX(NATIVE_FLOAT32));
+    rb_define_const(moduleNativeType, "FLOAT64", INT2FIX(NATIVE_FLOAT64));
+    rb_define_const(moduleNativeType, "POINTER", INT2FIX(NATIVE_POINTER));
+    rb_define_const(moduleNativeType, "STRING", INT2FIX(NATIVE_STRING));
+    rb_define_const(moduleNativeType, "RBXSTRING", INT2FIX(NATIVE_RBXSTRING));
+    rb_define_const(moduleNativeType, "CHAR_ARRAY", INT2FIX(NATIVE_CHAR_ARRAY));
+    rb_define_const(moduleNativeType, "BUFFER_IN", INT2FIX(NATIVE_BUFFER_IN));
+    rb_define_const(moduleNativeType, "BUFFER_OUT", INT2FIX(NATIVE_BUFFER_OUT));
+    rb_define_const(moduleNativeType, "BUFFER_INOUT", INT2FIX(NATIVE_BUFFER_INOUT));
+    rb_define_const(moduleNativeType, "VARARGS", INT2FIX(NATIVE_VARARGS));
+    if (sizeof(long) == 4) {
+        rb_define_const(moduleNativeType, "LONG", INT2FIX(NATIVE_INT32));
+        rb_define_const(moduleNativeType, "ULONG", INT2FIX(NATIVE_UINT32));
+    } else {
+        rb_define_const(moduleNativeType, "LONG", INT2FIX(NATIVE_INT64));
+        rb_define_const(moduleNativeType, "ULONG", INT2FIX(NATIVE_UINT64));
+    }
+    rb_FFI_Platform_Init();
+    rb_FFI_AbstractMemory_Init();
+    rb_FFI_Pointer_Init();
+    rb_FFI_AutoPointer_Init();
+    rb_FFI_NullPointer_Init();
+    rb_FFI_MemoryPointer_Init();
+    rb_FFI_Buffer_Init();
+    rb_FFI_Callback_Init();
+    rb_FFI_Struct_Init(0);
+    rb_FFI_NativeLibrary_Init();
+    rb_FFI_Invoker_Init();
+}
+

data/ext/ffi_c/ffi.mk

@@ -0,0 +1,23 @@
+# -*- makefile -*-
+
+# CFLAGS += -Werror -Wformat
+INCFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
+CPPFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
+# CPPFLAGS += -mwin32
+LOCAL_LIBS += $(LIBFFI)
+# LOCAL_LIBS += -lpthread
+
+FFI_CFLAGS = $(FFI_MMAP_EXEC)
+BUILD_DIR := $(shell pwd)
+ifeq ($(srcdir),.)
+  LIBFFI_SRC_DIR := $(shell pwd)/$(srcdir)/libffi
+else
+  LIBFFI_SRC_DIR := $(srcdir)/libffi
+endif
+LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
+LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a
+FFI_CONFIGURE = $(LIBFFI_SRC_DIR)/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	$(LIBFFI)
+

data/ext/ffi_c/libffi.mk

@@ -0,0 +1,11 @@
+# -*- makefile -*-
+
+$(LIBFFI):		
+	@mkdir -p $(LIBFFI_BUILD_DIR)
+	@if [ ! -f $(LIBFFI_BUILD_DIR)/Makefile ]; then \
+	    echo "Configuring libffi"; \
+	    cd $(LIBFFI_BUILD_DIR) && \
+		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(FFI_CFLAGS)" \
+		/bin/sh $(FFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
+	fi
+	cd $(LIBFFI_BUILD_DIR) && $(MAKE)