ffi 0.3.5 → 0.4.0

data/ext/ffi_c/Type.h

@@ -0,0 +1,28 @@
+#ifndef _TYPE_H
+#define	_TYPE_H
+
+#include <ruby.h>
+#include <ffi.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+    
+typedef struct Type_ {
+    NativeType nativeType;
+    ffi_type* ffiType;
+    int size;
+    int alignment;
+} Type;
+
+extern VALUE rbffi_TypeClass;
+extern int rbffi_Type_GetIntValue(VALUE type);
+
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _TYPE_H */
+

data/ext/ffi_c/Types.c

@@ -1,9 +1,13 @@
 #include <ruby.h>
 #include "Pointer.h"
+#include "rbffi.h"
+#include "Callback.h"
 #include "Types.h"
 
+static ID id_find = 0;
+
 ffi_type*
-rb_FFI_NativeTypeToFFI(NativeType type)
+rbffi_NativeType_ToFFI(NativeType type)
 {
     switch (type) {
         case NATIVE_VOID:
@@ -16,7 +20,9 @@ rb_FFI_NativeTypeToFFI(NativeType type)
             return &ffi_type_sint16;
         case NATIVE_UINT16:
             return &ffi_type_uint16;
+        case NATIVE_BOOL:
         case NATIVE_INT32:
+        case NATIVE_ENUM:
             return &ffi_type_sint32;
         case NATIVE_UINT32:
             return &ffi_type_uint32;
@@ -34,6 +40,7 @@ rb_FFI_NativeTypeToFFI(NativeType type)
         case NATIVE_BUFFER_IN:
         case NATIVE_BUFFER_OUT:
         case NATIVE_BUFFER_INOUT:
+        case NATIVE_CALLBACK:
             return &ffi_type_pointer;
         default:
             return NULL;
@@ -41,9 +48,9 @@ rb_FFI_NativeTypeToFFI(NativeType type)
 }
 
 VALUE
-rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
+rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums)
 {
-    switch (type) {
+    switch (type->nativeType) {
         case NATIVE_VOID:
             return Qnil;
         case NATIVE_INT8:
@@ -67,11 +74,45 @@ rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
         case NATIVE_FLOAT64:
             return rb_float_new(*(double *) ptr);
         case NATIVE_STRING:
-            return rb_tainted_str_new2(*(char **) ptr);
+            return (*(char **)ptr) ? rb_tainted_str_new2(*(char **) ptr) : Qnil;
         case NATIVE_POINTER:
-            return rb_FFI_Pointer_new(*(void **) ptr);
+            return rbffi_Pointer_NewInstance(*(void **) ptr);
+        case NATIVE_BOOL:
+            return ((int) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
+        case NATIVE_ENUM:
+        {
+            VALUE enum_obj = rb_funcall(enums, id_find, 1, rbType);
+            if (enum_obj == Qnil) {
+                VALUE s = rb_inspect(rbType);
+                rb_raise(rb_eRuntimeError, "Unknown enumeration: %s", StringValueCStr(s));
+            }
+            return rb_funcall(enum_obj, id_find, 1, INT2NUM((unsigned int) *(ffi_arg *) ptr));
+        }
+        case NATIVE_CALLBACK: {
+            CallbackInfo* cbInfo;
+            VALUE argv[6];
+            VALUE funcptr = rbffi_Pointer_NewInstance(*(void **) ptr);
+
+            Data_Get_Struct(rbType, CallbackInfo, cbInfo);
+            argv[0] = funcptr;
+            argv[1] = cbInfo->rbParameterTypes;
+            argv[2] = ID2SYM(rb_intern("cb")); // just shove a dummy value
+            argv[3] = cbInfo->rbReturnType;
+            argv[4] = rb_str_new2("default");
+            argv[5] = Qnil;
+
+            return rb_class_new_instance(6, argv, rbffi_InvokerClass);
+        }
+
         default:
-            rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
+            rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
             return Qnil;
     }
 }
+
+void
+rbffi_Types_Init(VALUE moduleFFI)
+{
+    id_find = rb_intern("find");
+}
+

data/ext/ffi_c/Types.h

@@ -25,6 +25,7 @@ typedef enum {
     NATIVE_BUFFER_OUT,
     NATIVE_BUFFER_INOUT,
     NATIVE_CHAR_ARRAY,
+    NATIVE_BOOL,
     
     /**
      * An immutable string.  Nul terminated, but only copies in to the native function
@@ -34,11 +35,16 @@ typedef enum {
     NATIVE_RBXSTRING,
     /** The function takes a variable number of arguments */
     NATIVE_VARARGS,
+    /** A typedef-ed enum */
+    NATIVE_ENUM,
 } NativeType;
 
 #include <ffi.h>
-extern ffi_type* rb_FFI_NativeTypeToFFI(NativeType type);
-VALUE rb_FFI_NativeValueToRuby(NativeType type, const void* ptr);
+#include "Type.h"
+
+extern ffi_type* rbffi_NativeType_ToFFI(NativeType type);
+VALUE rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr, VALUE enums);
+void rbffi_Types_Init(VALUE moduleFFI);
 
 #ifdef	__cplusplus
 }

data/ext/ffi_c/endian.h

@@ -0,0 +1,40 @@
+#ifndef JFFI_ENDIAN_H
+#define JFFI_ENDIAN_H
+
+#include <sys/param.h>
+#include <sys/types.h>
+
+#ifdef __linux__
+#  include_next <endian.h>
+#endif
+
+#ifdef __sun
+# include <sys/byteorder.h>
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(_BIG_ENDIAN)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(_LITTLE_ENDIAN)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if defined(_AIX) && !defined(BYTE_ORDER)
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(__BIG_ENDIAN__)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(__LITTLE_ENDIAN__)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
+#  error "Cannot determine the endian-ness of this platform"
+#endif
+
+#endif /* JFFI_ENDIAN_H */

data/ext/ffi_c/extconf.rb

@@ -16,15 +16,16 @@ $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 "CPPFLAGS += -Werror -Wunused -Wformat"
+  mf.puts "CPPFLAGS += -Werror -Wunused -Wformat -Wimplicit -Wreturn-type"
   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"
+    if Config::CONFIG['host_os'].downcase =~ /darwin/
+      mf.puts "include ${srcdir}/libffi.darwin.mk"
+    elsif Config::CONFIG['host_os'].downcase =~ /bsd/
+      mf.puts '.include "${srcdir}/libffi.bsd.mk"'
     else
-      mf.puts "include $(srcdir)/libffi.mk"
+      mf.puts "include ${srcdir}/libffi.mk"
     end
   end
 end

data/ext/ffi_c/ffi.c

@@ -10,20 +10,21 @@
 #include "MemoryPointer.h"
 #include "AutoPointer.h"
 #include "Struct.h"
-#include "NativeLibrary.h"
+#include "Callback.h"
+#include "DynamicLibrary.h"
 #include "Platform.h"
 #include "Types.h"
+#include "LastError.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)
+rbffi_type_size(VALUE type)
 {
     int t = TYPE(type);
     if (t == T_FIXNUM || t == T_BIGNUM) {
@@ -40,7 +41,7 @@ rb_FFI_type_size(VALUE type)
             }
         }
         // Not found - call up to the ruby version to resolve
-        return NUM2INT(rb_funcall2(moduleFFI, rb_intern("type_size"), 1, &type));
+        return NUM2INT(rb_funcall2(moduleFFI, type_size_id, 1, &type));
     } else {
         return NUM2INT(rb_funcall2(type, size_id, 0, NULL));
     }
@@ -50,50 +51,26 @@ 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();
-    rb_FFI_NativeLibrary_Init();
-    rb_FFI_Invoker_Init();
+
+    rbffi_Type_Init(moduleFFI);
+    rbffi_LastError_Init(moduleFFI);
+    rbffi_Platform_Init(moduleFFI);
+    rbffi_AbstractMemory_Init(moduleFFI);
+    rbffi_Pointer_Init(moduleFFI);
+    rbffi_AutoPointer_Init(moduleFFI);
+    rbffi_NullPointer_Init(moduleFFI);
+    rbffi_MemoryPointer_Init(moduleFFI);
+    rbffi_Buffer_Init(moduleFFI);
+    rbffi_Callback_Init(moduleFFI);
+    rbffi_Struct_Init(moduleFFI);
+    rbffi_DynamicLibrary_Init(moduleFFI);
+    rbffi_Invoker_Init(moduleFFI);
+    rbffi_Types_Init(moduleFFI);
 }
 

data/ext/ffi_c/libffi.bsd.mk

@@ -0,0 +1,34 @@
+# -*- makefile -*-
+#
+# Makefile for BSD systems
+#
+
+INCFLAGS += -I${LIBFFI_BUILD_DIR}/include
+LOCAL_LIBS += ${LIBFFI} -lpthread
+
+LIBFFI_CFLAGS = ${FFI_MMAP_EXEC} -pthread
+LIBFFI_BUILD_DIR = ${.CURDIR}/libffi
+
+.if "${srcdir}" == "."
+  LIBFFI_SRC_DIR := ${.CURDIR}/libffi
+.else
+  LIBFFI_SRC_DIR := ${srcdir}/libffi
+.endif
+
+
+LIBFFI = ${LIBFFI_BUILD_DIR}/.libs/libffi_convenience.a
+LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	${LIBFFI}
+
+$(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="${LIBFFI_CFLAGS}" \
+		/bin/sh ${LIBFFI_CONFIGURE} ${LIBFFI_HOST} > /dev/null; \
+	fi
+	@cd ${LIBFFI_BUILD_DIR} && ${MAKE}
+

data/ext/ffi_c/libffi.darwin.mk

@@ -1,32 +1,52 @@
 # -*- makefile -*-
-ARCHES := 
+
+include ${srcdir}/libffi.gnu.mk
+
 CCACHE := $(shell type -p ccache)
+BUILD_DIR := $(shell pwd)
+
+INCFLAGS += -I${BUILD_DIR}
+
+# Work out which arches we need to compile the lib for
+ARCHES := 
 ifneq ($(findstring -arch ppc,$(CFLAGS)),)
   ARCHES += ppc
 endif
+
 ifneq ($(findstring -arch i386,$(CFLAGS)),)
   ARCHES += i386
 endif
+
 ifneq ($(findstring -arch x86_64,$(CFLAGS)),)
   ARCHES += x86_64
 endif
-ifeq ($(ARCHES),)
-  ARCHES = $(shell arch)
-endif
 
+ifeq ($(strip $(ARCHES)),)
+# Just build the one (default) architecture
+$(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="$(LIBFFI_CFLAGS)" \
+		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
+	fi
+	cd $(LIBFFI_BUILD_DIR) && $(MAKE)
+
+else
+# Build a fat binary and assemble
 build_ffi = \
 	mkdir -p $(BUILD_DIR)/libffi-$(1); \
 	(if [ ! -f $(BUILD_DIR)/libffi-$(1)/Makefile ]; then \
 	    echo "Configuring libffi for $(1)"; \
 	    cd $(BUILD_DIR)/libffi-$(1) && \
-	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(FFI_CFLAGS)" LDFLAGS="-arch $(1)" \
-		$(FFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
+	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(LIBFFI_CFLAGS)" LDFLAGS="-arch $(1)" \
+		$(LIBFFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
 	fi); \
 	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C $(BUILD_DIR)/libffi-$(1)
-	
+
 $(LIBFFI):
-	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done
-	
+	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done	
 	# Assemble into a FAT (i386, ppc) library
 	@mkdir -p $(BUILD_DIR)/libffi/.libs
 	env MACOSX_DEPLOYMENT_TARGET=10.4 /usr/bin/libtool -static -o $@ \
@@ -51,5 +71,5 @@ $(LIBFFI):
 		printf "#include \"libffi-ppc/include/ffitarget.h\"\n";\
 		printf "#endif\n";\
 	) > $(LIBFFI_BUILD_DIR)/include/ffitarget.h
-	
 
+endif

data/ext/ffi_c/libffi.gnu.mk

@@ -0,0 +1,29 @@
+# -*- makefile -*-
+#
+#  Common definitions for all systems that use GNU make
+#
+
+
+# Tack the extra deps onto the autogenerated variables
+INCFLAGS += -I$(LIBFFI_BUILD_DIR)/include
+LOCAL_LIBS += $(LIBFFI)
+BUILD_DIR = $(shell pwd)
+LIBFFI_CFLAGS = $(FFI_MMAP_EXEC)
+LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi
+
+ifeq ($(srcdir),.)
+  LIBFFI_SRC_DIR := $(shell pwd)/libffi
+else
+  LIBFFI_SRC_DIR := $(srcdir)/libffi
+endif
+
+LIBFFI = $(LIBFFI_BUILD_DIR)/.libs/libffi_convenience.a
+LIBFFI_CONFIGURE = $(LIBFFI_SRC_DIR)/configure --disable-static \
+	--with-pic=yes --disable-dependency-tracking
+
+$(OBJS):	$(LIBFFI)
+
+#
+# libffi.mk or libffi.darwin.mk contains rules for building the actual library
+#
+

data/ext/ffi_c/libffi.mk

@@ -1,11 +1,13 @@
 # -*- makefile -*-
 
+include ${srcdir}/libffi.gnu.mk
+
 $(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; \
+		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(LIBFFI_CFLAGS)" \
+		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
 	fi
 	cd $(LIBFFI_BUILD_DIR) && $(MAKE)