ffi 1.0.9 → 1.0.10

data/ext/ffi_c/Type.c

@@ -51,6 +51,12 @@ type_allocate(VALUE klass)
     return obj;
 }
 
+/*
+ * Document-method: initialize
+ * call-seq: initialize(value)
+ * @param [Fixnum,Type] value
+ * @return [self]
+ */
 static VALUE
 type_initialize(VALUE self, VALUE value)
 {
@@ -72,6 +78,11 @@ type_initialize(VALUE self, VALUE value)
     return self;
 }
 
+/*
+ * call-seq: type.size
+ * @return [Fixnum]
+ * Return type's size, in bytes.
+ */
 static VALUE
 type_size(VALUE self)
 {
@@ -82,6 +93,10 @@ type_size(VALUE self)
     return INT2FIX(type->ffiType->size);
 }
 
+/*
+ * call-seq: type.alignment
+ * @return [Fixnum]
+ */
 static VALUE
 type_alignment(VALUE self)
 {
@@ -92,6 +107,11 @@ type_alignment(VALUE self)
     return INT2FIX(type->ffiType->alignment);
 }
 
+/*
+ * call-seq: type.inspect
+ * @return [String]
+ * Inspect {Type} object.
+ */
 static VALUE
 type_inspect(VALUE self)
 {
@@ -128,6 +148,11 @@ builtin_type_free(BuiltinType *type)
     xfree(type);
 }
 
+/*
+ * call-seq: type.inspect
+ * @return [String]
+ * Inspect {Type::Builtin} object.
+ */
 static VALUE
 builtin_type_inspect(VALUE self)
 {
@@ -145,21 +170,29 @@ int
 rbffi_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);
+        if ((nType = rb_hash_lookup(typeMap, type)) != Qnil) {
+            if (rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+                Type* type;
+                Data_Get_Struct(nType, Type, type);
+                return (int) type->ffiType->size;
+            
+            } else if (rb_respond_to(nType, id_size)) {
+                return NUM2INT(rb_funcall2(nType, id_size, 0, NULL));
             }
         }
+
         // Not found - call up to the ruby version to resolve
         return NUM2INT(rb_funcall2(rbffi_FFIModule, id_type_size, 1, &type));
+    
     } else {
         return NUM2INT(rb_funcall2(type, id_size, 0, NULL));
     }
@@ -174,7 +207,7 @@ rbffi_Type_Lookup(VALUE name)
          * Try looking up directly in the type Map
          */
         VALUE nType;
-        if ((nType = rb_hash_aref(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
+        if ((nType = rb_hash_lookup(typeMap, name)) != Qnil && rb_obj_is_kind_of(nType, rbffi_TypeClass)) {
             return nType;
         }
     } else if (rb_obj_is_kind_of(name, rbffi_TypeClass)) {
@@ -196,7 +229,9 @@ rbffi_Type_Find(VALUE name)
     VALUE rbType = rbffi_Type_Lookup(name);
 
     if (!RTEST(rbType)) {
-        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(rb_inspect(name)));
+        VALUE s = rb_inspect(name);
+        rb_raise(rb_eTypeError, "invalid type, %s", RSTRING_PTR(s));
+        RB_GC_GUARD(s);
     }
 
     return rbType;
@@ -206,8 +241,18 @@ void
 rbffi_Type_Init(VALUE moduleFFI)
 {
     VALUE moduleNativeType;
-    VALUE classType = rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
-
+    /*
+     * Document-class: FFI::Type
+     * This class manages C types.
+     *
+     * It embbed {FFI::Type::Builtin} objects as constants (for names,
+     * see {FFI::NativeType}).
+     */
+    rbffi_TypeClass = rb_define_class_under(moduleFFI, "Type", rb_cObject);
+
+    /*
+     * Document-constant: FFI::TypeDefs
+     */
     rb_define_const(moduleFFI, "TypeDefs", typeMap = rb_hash_new());
     rb_define_const(moduleFFI, "SizeTypes", sizeMap = rb_hash_new());
     rb_global_variable(&typeMap);
@@ -216,19 +261,62 @@ rbffi_Type_Init(VALUE moduleFFI)
     id_type_size = rb_intern("type_size");
     id_size = rb_intern("size");
 
-
+    /*
+     * Document-class: FFI::Type::Builtin
+     * Class for Built-in types.
+     */
     classBuiltinType = rb_define_class_under(rbffi_TypeClass, "Builtin", rbffi_TypeClass);
+    /*
+     * Document-module: FFI::NativeType
+     * This module defines constants for native (C) types.
+     *
+     * ==Native type constants
+     * Native types are defined by constants :
+     * * INT8, SCHAR, CHAR
+     * * UINT8, UCHAR
+     * * INT16, SHORT, SSHORT
+     * * UINT16, USHORT
+     * * INT32,, INT, SINT
+     * * UINT32, UINT
+     * * INT64, LONG_LONG, SLONG_LONG
+     * * UINT64, ULONG_LONG
+     * * LONG, SLONG
+     * * ULONG
+     * * FLOAT32, FLOAT
+     * * FLOAT64, DOUBLE
+     * * POINTER
+     * * CALLBACK
+     * * FUNCTION
+     * * CHAR_ARRAY
+     * * BOOL
+     * * STRING (immutable string, nul terminated)
+     * * STRUCT (struct-b-value param or result)
+     * * ARRAY (array type definition)
+     * * MAPPED (custom native type)
+     * For function return type only :
+     * * VOID
+     * For function argument type only :
+     * * BUFFER_IN
+     * * BUFFER_OUT
+     * * VARARGS (function takes a variable number of arguments)
+     *
+     * All these constants are exported to {FFI} module prefixed with "TYPE_". 
+     * They are objets from {FFI::Type::Builtin} class.
+     */
     moduleNativeType = rb_define_module_under(moduleFFI, "NativeType");
 
+    /*
+     * Document-global: FFI::Type
+     */
     rb_global_variable(&rbffi_TypeClass);
     rb_global_variable(&classBuiltinType);
     rb_global_variable(&moduleNativeType);
 
-    rb_define_alloc_func(classType, type_allocate);
-    rb_define_method(classType, "initialize", type_initialize, 1);
-    rb_define_method(classType, "size", type_size, 0);
-    rb_define_method(classType, "alignment", type_alignment, 0);
-    rb_define_method(classType, "inspect", type_inspect, 0);
+    rb_define_alloc_func(rbffi_TypeClass, type_allocate);
+    rb_define_method(rbffi_TypeClass, "initialize", type_initialize, 1);
+    rb_define_method(rbffi_TypeClass, "size", type_size, 0);
+    rb_define_method(rbffi_TypeClass, "alignment", type_alignment, 0);
+    rb_define_method(rbffi_TypeClass, "inspect", type_inspect, 0);
 
     // Make Type::Builtin non-allocatable
     rb_undef_method(CLASS_OF(classBuiltinType), "new");
@@ -240,16 +328,19 @@ rbffi_Type_Init(VALUE moduleFFI)
     // Define all the builtin types
     #define T(x, ffiType) do { \
         VALUE t = Qnil; \
-        rb_define_const(classType, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
+        rb_define_const(rbffi_TypeClass, #x, t = builtin_type_new(classBuiltinType, NATIVE_##x, ffiType, #x)); \
         rb_define_const(moduleNativeType, #x, t); \
         rb_define_const(moduleFFI, "TYPE_" #x, t); \
     } while(0)
 
     #define A(old_type, new_type) do { \
-        VALUE t = rb_const_get(classType, rb_intern(#old_type)); \
-        rb_const_set(classType, rb_intern(#new_type), t); \
+        VALUE t = rb_const_get(rbffi_TypeClass, rb_intern(#old_type)); \
+        rb_const_set(rbffi_TypeClass, rb_intern(#new_type), t); \
     } while(0)
 
+    /*
+     * Document-constant: FFI::Type::Builtin::VOID
+     */
     T(VOID, &ffi_type_void);
     T(INT8, &ffi_type_sint8);
     A(INT8, SCHAR);

data/ext/ffi_c/Types.c

@@ -86,6 +86,8 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
 
             Data_Get_Struct(rbMemory, AbstractMemory, mem);
             memcpy(mem->address, ptr, sbv->base.ffiType->size);
+            RB_GC_GUARD(rbMemory);
+            RB_GC_GUARD(rbType);
 
             return rb_class_new_instance(1, &rbMemory, sbv->rbStructClass);
         }
@@ -94,12 +96,17 @@ rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
             // For mapped types, first convert to the real native type, then upcall to
             // ruby to convert to the expected return type
             MappedType* m = (MappedType *) type;
-            VALUE values[2];
+            VALUE values[2], rbReturnValue;
 
             values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr);
             values[1] = Qnil;
+            
 
-            return rb_funcall2(m->rbConverter, id_from_native, 2, values);
+            rbReturnValue = rb_funcall2(m->rbConverter, id_from_native, 2, values);
+            RB_GC_GUARD(values[0]);
+            RB_GC_GUARD(rbType);
+            
+            return rbReturnValue;
         }
     
         default:

data/ext/ffi_c/Variadic.c

@@ -86,7 +86,8 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     VALUE retval = Qnil;
     VALUE convention = Qnil;
     VALUE fixed = Qnil;
-    int i;
+	VALUE rbConventionStr;
+	int i;
 
     Check_Type(options, T_HASH);
     convention = rb_hash_aref(options, ID2SYM(rb_intern("convention")));
@@ -97,7 +98,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
 
 #if defined(_WIN32) || defined(__WIN32__)
-    VALUE rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL);
+    rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL);
     invoker->abi = (RTEST(convention) && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)
             ? FFI_STDCALL : FFI_DEFAULT_ABI;
 #else
@@ -159,7 +160,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     Check_Type(parameterValues, T_ARRAY);
 
     Data_Get_Struct(self, VariadicInvoker, invoker);
-    paramCount = RARRAY_LEN(parameterTypes);
+    paramCount = (int) RARRAY_LEN(parameterTypes);
     paramTypes = ALLOCA_N(Type *, paramCount);
     ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
     params = ALLOCA_N(FFIStorage, paramCount);
@@ -201,7 +202,7 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
         
         ffiParamTypes[i] = paramTypes[i]->ffiType;
         if (ffiParamTypes[i] == NULL) {
-            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]);
+            rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]->nativeType);
         }
         argv[i] = rb_ary_entry(parameterValues, i);
     }

data/ext/ffi_c/compat.h

@@ -62,5 +62,13 @@
 #  define MIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
+#ifndef RB_GC_GUARD(x)
+#  define RB_GC_GUARD(x) (x)
+#endif
+
+#ifndef RB_GC_GUARD_PTR(x)
+#  define RB_GC_GUARD_PTR(x) (x)
+#endif
+
 #endif /* RBFFI_COMPAT_H */
 

data/ext/ffi_c/endian.h

@@ -4,7 +4,7 @@
 #include <sys/param.h>
 #include <sys/types.h>
 
-#if defined(__linux__) || defined(__CYGWIN__)
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__)
 #  include_next <endian.h>
 #endif
 
@@ -33,6 +33,12 @@
 # endif
 #endif
 
+#if defined(_WIN32)
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# define BYTE_ORDER LITTLE_ENDIAN
+#endif
+
 #if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
 #  error "Cannot determine the endian-ness of this platform"
 #endif

data/ext/ffi_c/extconf.rb

@@ -1,46 +1,57 @@
 #!/usr/bin/env ruby
-require 'mkmf'
-require 'rbconfig'
-dir_config("ffi_c")
 
-unless RbConfig::CONFIG['host_os'] =~ /mswin32|mingw32/
-  if pkg_config("libffi") || find_header("ffi.h", "/usr/local/include")
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+  require 'mkmf'
+  require 'rbconfig'
+  dir_config("ffi_c")
+  
+  if pkg_config("libffi") ||
+     have_header("ffi.h") ||
+     find_header("ffi.h", "/usr/local/include")
 
     # We need at least ffi_call and ffi_prep_closure
-    libffi_ok = have_library("ffi", "ffi_call", [ "ffi.h" ]) && have_func("ffi_prep_closure")
-    
+    libffi_ok = have_library("ffi", "ffi_call", [ "ffi.h" ]) ||
+                have_library("libffi", "ffi_call", [ "ffi.h" ])
+    libffi_ok &&= have_func("ffi_prep_closure")
+
     # Check if the raw api is available.
     $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
   end
-end
-
-have_func('rb_thread_blocking_region')
-have_func('ruby_thread_has_gvl_p')
-have_func('ruby_native_thread_p')
-have_func('rb_thread_call_with_gvl')
-
-$defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
-$defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
-$defs << "-DRUBY_1_9" if RUBY_VERSION >= "1.9.0"
-
-create_header
+  
+  have_func('rb_thread_blocking_region')
+  have_func('ruby_thread_has_gvl_p') unless RUBY_VERSION >= "1.9.3"
+  have_func('ruby_native_thread_p')
+  have_func('rb_thread_call_with_gvl')
+  
+  $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
+  $defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
+  $defs << "-DRUBY_1_9" if RUBY_VERSION >= "1.9.0"
 
-$CFLAGS << " -mwin32 " if RbConfig::CONFIG['host_os'] =~ /cygwin/
-#$CFLAGS << " -Werror -Wunused -Wformat -Wimplicit -Wreturn-type "
-if (ENV['CC'] || RbConfig::MAKEFILE_CONFIG['CC'])  =~ /gcc/
-  $CFLAGS << " -Wno-declaration-after-statement "
-end
-
-create_makefile("ffi_c")
-unless libffi_ok
-  File.open("Makefile", "a") do |mf|
-    mf.puts "LIBFFI_HOST=--host=#{RbConfig::CONFIG['host_alias']}" if RbConfig::CONFIG.has_key?("host_alias")
-    if RbConfig::CONFIG['host_os'].downcase =~ /darwin/
-      mf.puts "include ${srcdir}/libffi.darwin.mk"
-    elsif RbConfig::CONFIG['host_os'].downcase =~ /bsd/
-      mf.puts '.include "${srcdir}/libffi.bsd.mk"'
-    else
-      mf.puts "include ${srcdir}/libffi.mk"
+  create_header
+  
+  $CFLAGS << " -mwin32 " if RbConfig::CONFIG['host_os'] =~ /cygwin/
+  #$CFLAGS << " -Werror -Wunused -Wformat -Wimplicit -Wreturn-type "
+  if (ENV['CC'] || RbConfig::MAKEFILE_CONFIG['CC'])  =~ /gcc/
+    $CFLAGS << " -Wno-declaration-after-statement "
+  end
+  
+  create_makefile("ffi_c")
+  unless libffi_ok
+    File.open("Makefile", "a") do |mf|
+      mf.puts "LIBFFI_HOST=--host=#{RbConfig::CONFIG['host_alias']}" if RbConfig::CONFIG.has_key?("host_alias")
+      if RbConfig::CONFIG['host_os'].downcase =~ /darwin/
+        mf.puts "include ${srcdir}/libffi.darwin.mk"
+      elsif RbConfig::CONFIG['host_os'].downcase =~ /bsd/
+        mf.puts '.include "${srcdir}/libffi.bsd.mk"'
+      elsif RbConfig::CONFIG['host_os'] !~ /mswin32|mingw32/
+        mf.puts "include ${srcdir}/libffi.mk"
+      end
     end
   end
+  
+else
+  File.open("Makefile", "w") do |mf|
+    mf.puts "# Dummy makefile for non-mri rubies"
+    mf.puts "all install::\n"
+  end
 end

data/ext/ffi_c/ffi.c

@@ -50,6 +50,11 @@ static VALUE moduleFFI = Qnil;
 
 void
 Init_ffi_c(void) {
+    /* 
+     * Document-module: FFI
+     *
+     * This module embbed type constants from {FFI::NativeType}.
+     */
     rbffi_FFIModule = moduleFFI = rb_define_module("FFI");
     rb_global_variable(&moduleFFI);
 

data/ext/ffi_c/libffi.darwin.mk

@@ -5,7 +5,7 @@ include ${srcdir}/libffi.gnu.mk
 CCACHE := $(shell type -p ccache)
 BUILD_DIR := $(shell pwd)
 
-INCFLAGS += -I${BUILD_DIR}
+INCFLAGS += -I"$(BUILD_DIR)"
 
 # Work out which arches we need to compile the lib for
 ARCHES := 
@@ -24,35 +24,35 @@ endif
 ifeq ($(strip $(ARCHES)),)
 # Just build the one (default) architecture
 $(LIBFFI):		
-	@mkdir -p $(LIBFFI_BUILD_DIR)
-	@if [ ! -f $(LIBFFI_BUILD_DIR)/Makefile ]; then \
+	@mkdir -p "$(LIBFFI_BUILD_DIR)"
+	@if [ ! -f "$(LIBFFI_BUILD_DIR)"/Makefile ]; then \
 	    echo "Configuring libffi"; \
-	    cd $(LIBFFI_BUILD_DIR) && \
+	    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)
+	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 \
+	mkdir -p "$(BUILD_DIR)"/libffi-$(1); \
+	(if [ ! -f "$(BUILD_DIR)"/libffi-$(1)/Makefile ]; then \
 	    echo "Configuring libffi for $(1)"; \
-	    cd $(BUILD_DIR)/libffi-$(1) && \
+	    cd "$(BUILD_DIR)"/libffi-$(1) && \
 	      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)
+	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C "$(BUILD_DIR)"/libffi-$(1)
 
 $(LIBFFI):
 	@for arch in $(ARCHES); do $(call build_ffi,$$arch);done	
 	# Assemble into a FAT (x86_64, i386, ppc) library
-	@mkdir -p $(BUILD_DIR)/libffi/.libs
+	@mkdir -p "$(BUILD_DIR)"/libffi/.libs
 	/usr/bin/libtool -static -o $@ \
-	    $(foreach arch, $(ARCHES),$(BUILD_DIR)/libffi-$(arch)/.libs/libffi_convenience.a)
-	@mkdir -p $(LIBFFI_BUILD_DIR)/include
-	$(RM) $(LIBFFI_BUILD_DIR)/include/ffi.h
+	    $(foreach arch, $(ARCHES),"$(BUILD_DIR)"/libffi-$(arch)/.libs/libffi_convenience.a)
+	@mkdir -p "$(LIBFFI_BUILD_DIR)"/include
+	$(RM) "$(LIBFFI_BUILD_DIR)"/include/ffi.h
 	@( \
 		printf "#if defined(__i386__)\n"; \
 		printf "#include \"libffi-i386/include/ffi.h\"\n"; \
@@ -61,7 +61,7 @@ $(LIBFFI):
 		printf "#elif defined(__ppc__)\n"; \
 		printf "#include \"libffi-ppc/include/ffi.h\"\n";\
 		printf "#endif\n";\
-	) > $(LIBFFI_BUILD_DIR)/include/ffi.h
+	) > "$(LIBFFI_BUILD_DIR)"/include/ffi.h
 	@( \
 		printf "#if defined(__i386__)\n"; \
 		printf "#include \"libffi-i386/include/ffitarget.h\"\n"; \
@@ -70,6 +70,6 @@ $(LIBFFI):
 		printf "#elif defined(__ppc__)\n"; \
 		printf "#include \"libffi-ppc/include/ffitarget.h\"\n";\
 		printf "#endif\n";\
-	) > $(LIBFFI_BUILD_DIR)/include/ffitarget.h
+	) > "$(LIBFFI_BUILD_DIR)"/include/ffitarget.h
 
 endif