ffi 0.1.1 → 0.2.0

data/ext/Types.c

@@ -1,5 +1,5 @@
 #include <ruby.h>
-#include "MemoryPointer.h"
+#include "Pointer.h"
 #include "Types.h"
 
 ffi_type*
@@ -12,6 +12,10 @@ rb_FFI_NativeTypeToFFI(NativeType type)
             return &ffi_type_sint8;
         case UINT8:
             return &ffi_type_uint8;
+        case INT16:
+            return &ffi_type_sint16;
+        case UINT16:
+            return &ffi_type_uint16;
         case INT32:
             return &ffi_type_sint32;
         case UINT32:
@@ -27,6 +31,9 @@ rb_FFI_NativeTypeToFFI(NativeType type)
         case STRING:
         case RBXSTRING:
         case POINTER:
+        case BUFFER_IN:
+        case BUFFER_OUT:
+        case BUFFER_INOUT:
             return &ffi_type_pointer;
         default:
             return NULL;
@@ -40,13 +47,17 @@ rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
         case VOID:
             return Qnil;        
         case INT8:
+            return INT2NUM(*(char *) ptr);
         case INT16:
+            return INT2NUM(*(short *) ptr);
         case INT32:
-            return INT2FIX(*(int *) ptr);
+            return INT2NUM(*(int *) ptr);
         case UINT8:
+            return UINT2NUM(*(unsigned char *) ptr);
         case UINT16:
+            return UINT2NUM(*(unsigned short *) ptr);
         case UINT32:
-            return INT2FIX(*(unsigned int *) ptr);
+            return UINT2NUM(*(unsigned int *) ptr);
         case INT64:
             return LL2NUM(*(signed long long *) ptr);
         case UINT64:
@@ -56,9 +67,9 @@ rb_FFI_NativeValueToRuby(NativeType type, const void* ptr)
         case FLOAT64:
             return rb_float_new(*(double *) ptr);
         case STRING:
-            return rb_str_new2(*(char **) ptr);
+            return rb_tainted_str_new2(*(char **) ptr);
         case POINTER:
-            return rb_FFI_MemoryPointer_new(*(void **) ptr);
+            return rb_FFI_Pointer_new(*(void **) ptr);
         default:
             rb_raise(rb_eRuntimeError, "Unknown type: %d", type);
     }

data/ext/Types.h

@@ -36,7 +36,9 @@ typedef enum {
      */
     STRING,
     /** A Rubinus :string arg - copies data both ways, and nul terminates */
-    RBXSTRING
+    RBXSTRING,
+    /** The function takes a variable number of arguments */
+    VARARGS,
 } NativeType;
 
 #include <ffi.h>

data/ext/compat.h

@@ -1,8 +1,22 @@
 #ifndef FFI_COMPAT_H
 #define FFI_COMPAT_H
 
+#include <ruby.h>
+
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(ary) RARRAY(ary)->len
 #endif
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(s) RSTRING(s)->len
+#endif
+#ifndef RSTRING_LEN
+#  define RSTRING_LEN(s) RSTRING(s)->len
+#endif
+#ifndef RSTRING_PTR
+#  define RSTRING_PTR(s) RSTRING(s)->ptr
+#endif
+#ifndef NUM2ULL
+#  define NUM2ULL(x) rb_num2ull((VALUE)x)
+#endif
 
 #endif /* FFI_COMPAT_H */

data/ext/extconf.rb

@@ -2,7 +2,19 @@
 require 'mkmf'
 require 'rbconfig'
 dir_config("ffi_c")
+IS_MAC = Config::CONFIG['host_os'] =~ /^darwin/
+#if IS_MAC
+#  $CPPFLAGS << " -DMACOSX"
+#  find_header("ffi.h", "/usr/include/ffi")
+#end
+have_closure_alloc = have_library("ffi", "ffi_closure_alloc", [ "ffi.h" ])
+$defs.push("-DHAVE_FFI_CLOSURE_ALLOC") if have_closure_alloc
+libffi_ok = have_closure_alloc
+$defs << "-DHAVE_LIBFFI" if libffi_ok
+$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/
@@ -10,4 +22,4 @@ File.open("Makefile", "a") do |mf|
   else
     mf.puts "include $(srcdir)/libffi.mk"
   end
-end
+end unless libffi_ok

data/ext/ffi.c

@@ -7,7 +7,10 @@
 
 #include "rbffi.h"
 #include "AbstractMemory.h"
+#include "Pointer.h"
 #include "MemoryPointer.h"
+#include "AutoPointer.h"
+#include "NativeLibrary.h"
 #include "Platform.h"
 #include "Types.h"
 
@@ -37,6 +40,10 @@ Init_ffi_c() {
     rb_define_const(moduleNativeType, "STRING", INT2FIX(STRING));
     rb_define_const(moduleNativeType, "RBXSTRING", INT2FIX(RBXSTRING));
     rb_define_const(moduleNativeType, "CHAR_ARRAY", INT2FIX(CHAR_ARRAY));
+    rb_define_const(moduleNativeType, "BUFFER_IN", INT2FIX(BUFFER_IN));
+    rb_define_const(moduleNativeType, "BUFFER_OUT", INT2FIX(BUFFER_OUT));
+    rb_define_const(moduleNativeType, "BUFFER_INOUT", INT2FIX(BUFFER_INOUT));
+    rb_define_const(moduleNativeType, "VARARGS", INT2FIX(VARARGS));
     if (sizeof(long) == 4) {
         rb_define_const(moduleNativeType, "LONG", INT2FIX(INT32));
         rb_define_const(moduleNativeType, "ULONG", INT2FIX(UINT32));
@@ -46,9 +53,12 @@ Init_ffi_c() {
     }
     rb_FFI_Platform_Init();
     rb_FFI_AbstractMemory_Init();
+    rb_FFI_Pointer_Init();
+    rb_FFI_AutoPointer_Init();
     rb_FFI_MemoryPointer_Init();
     rb_FFI_Buffer_Init();
     rb_FFI_Callback_Init();
-    rb_FFI_Invoker_Init();    
+    rb_FFI_NativeLibrary_Init();
+    rb_FFI_Invoker_Init();
 }
 

data/ext/ffi.mk

@@ -1,9 +1,9 @@
 # -*- makefile -*-
 
-CFLAGS += -Werror
-LIBS += -lpthread
+CFLAGS += -Werror -Wformat
 INCFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
-LOCAL_LIBS += $(LIBFFI)
+CPPFLAGS += -I$(BUILD_DIR) -I$(LIBFFI_BUILD_DIR)/include
+LOCAL_LIBS += $(LIBFFI) -lpthread
 
 FFI_MMAP_EXEC = -DFFI_MMAP_EXEC_WRIT
 FFI_CFLAGS = $(FFI_MMAP_EXEC) $(OFLAGS)

data/ext/libffi.darwin.mk

@@ -1,26 +1,36 @@
 # -*- makefile -*-
+ARCHES := 
+CCACHE := $(shell type -p ccache)
+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
 
 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 CFLAGS="-arch $(1) $(FFI_CFLAGS)" LDFLAGS="-arch $(1)" \
+	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(FFI_CFLAGS)" LDFLAGS="-arch $(1)" \
 		$(FFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
 	fi); \
 	env MACOSX_DEPLOYMENT_TARGET=10.4 $(MAKE) -C $(BUILD_DIR)/libffi-$(1)
 	
 $(LIBFFI):
-	@$(call build_ffi,i386)
-	@$(call build_ffi,ppc)
-	@$(call build_ffi,x86_64)
+	@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 $@ \
-            $(BUILD_DIR)/libffi-i386/.libs/libffi_convenience.a \
-	    $(BUILD_DIR)/libffi-x86_64/.libs/libffi_convenience.a \
-	    $(BUILD_DIR)/libffi-ppc/.libs/libffi_convenience.a
+	    $(foreach arch, $(ARCHES),$(BUILD_DIR)/libffi-$(arch)/.libs/libffi_convenience.a)
 	@mkdir -p $(LIBFFI_BUILD_DIR)/include
 	$(RM) $(LIBFFI_BUILD_DIR)/include/ffi.h
 	@( \
@@ -41,4 +51,5 @@ $(LIBFFI):
 		printf "#include \"libffi-ppc/include/ffitarget.h\"\n";\
 		printf "#endif\n";\
 	) > $(LIBFFI_BUILD_DIR)/include/ffitarget.h
-	
+	
+

data/gen/Rakefile

@@ -0,0 +1,12 @@
+require 'fileutils'
+require "#{File.join(ENV['RUBYLIBDIR'], 'ffi', 'tools', 'types_generator.rb')}"
+types_conf = File.join(ENV['RUBYLIBDIR'], 'ffi', 'types.conf') 
+task types_conf do |task|
+  options = {}
+  FileUtils.mkdir_p(File.dirname(task.name), { :mode => 0755 })
+  File.open(task.name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
+    f.puts FFI::TypesGenerator.generate(options)
+  end
+end
+task :default => types_conf do
+end

data/lib/ffi/autopointer.rb

@@ -0,0 +1,61 @@
+module FFI
+  class AutoPointer < Pointer
+
+    # call-seq:
+    #   AutoPointer.new(pointer, method)     => the passed Method will be invoked at GC time
+    #   AutoPointer.new(pointer, proc)       => the passed Proc will be invoked at GC time (SEE WARNING BELOW!)
+    #   AutoPointer.new(pointer) { |p| ... } => the passed block will be invoked at GC time (SEE WARNING BELOW!)
+    #   AutoPointer.new(pointer)             => the pointer's release() class method will be invoked at GC time
+    #
+    # WARNING: passing a proc _may_ cause your pointer to never be GC'd, unless you're careful to avoid trapping a reference to the pointer in the proc. See the test specs for examples.
+    # WARNING: passing a block will cause your pointer to never be GC'd. This is bad.
+    #
+    # Please note that the safest, and therefore preferred, calling
+    # idiom is to pass a Method as the second parameter. Example usage:
+    #
+    #   class PointerHelper
+    #     def self.release(pointer)
+    #       ...
+    #     end
+    #   end
+    #
+    #   p = AutoPointer.new(other_pointer, PointerHelper.method(:release))
+    #
+    # The above code will cause PointerHelper#release to be invoked at GC time.
+    #
+    # The last calling idiom (only one parameter) is generally only
+    # going to be useful if you subclass AutoPointer, and override
+    # release(), which by default does nothing.
+    #
+    def self.new(ptr, proc=nil, &block)
+      raise ArgumentError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
+        || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
+      free_lambda = if proc and proc.is_a? Method
+                      finalize(ptr, self.method_to_proc(proc))
+                    elsif proc and proc.is_a? Proc
+                      finalize(ptr, proc)
+                    else
+                      finalize(ptr, self.method_to_proc(self.method(:release)))
+                    end
+      ap = self.__alloc(ptr)
+      ObjectSpace.define_finalizer(ap, free_lambda)
+      ap
+    end
+    def self.release(ptr)
+    end
+
+    private
+    def self.finalize(ptr, proc)
+      #
+      #  having a method create the lambda eliminates inadvertent
+      #  references to the underlying object, which would prevent GC
+      #  from running.
+      #
+      Proc.new { |*args| proc.call(ptr) }
+    end
+    def self.method_to_proc method
+      #  again, can't call this inline as it causes a memory leak.
+      method.to_proc
+    end
+  end
+end

data/lib/ffi/errno.rb

@@ -0,0 +1,8 @@
+module FFI
+  def self.errno
+    FFI::LastError.error
+  end
+  def self.errno=(error)
+    FFI::LastError.error = error
+  end
+end

data/lib/ffi/ffi.rb

@@ -1,30 +1,5 @@
 #
-# Version: CPL 1.0/GPL 2.0/LGPL 2.1
-#
-# The contents of this file are subject to the Common Public
-# License Version 1.0 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.eclipse.org/legal/cpl-v10.html
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
 # Copyright (C) 2008 JRuby project
-#
-# Alternatively, the contents of this file may be used under the terms of
-# either of the GNU General Public License Version 2 or later (the "GPL"),
-# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
-# in which case the provisions of the GPL or the LGPL are applicable instead
-# of those above. If you wish to allow use of your version of this file only
-# under the terms of either the GPL or the LGPL, and not to allow others to
-# use your version of this file under the terms of the CPL, indicate your
-# decision by deleting the provisions above and replace them with the notice
-# and other provisions required by the GPL or the LGPL. If you do not delete
-# the provisions above, a recipient may use your version of this file under
-# the terms of any one of the CPL, the GPL or the LGPL.
-#
 # Copyright (c) 2007, 2008 Evan Phoenix
 # All rights reserved.
 #
@@ -60,200 +35,62 @@ module FFI
   class SignatureError < NativeError; end
   
   class NotFoundError < NativeError
-    def initialize(function, library)
-      super("Function '#{function}' not found! (Looking in '#{library}' or this process)")
+    def initialize(function, *libraries)
+      super("Function '#{function}' not found in [#{libraries[0].nil? ? 'current process' : libraries.join(", ")}]")
     end
   end
 end
 
 require 'ffi/platform'
+require 'ffi/types'
+require 'ffi/library'
+require 'ffi/errno'
 require 'ffi/memorypointer'
 require 'ffi/buffer'
 require 'ffi/struct'
+require 'ffi/managedstruct'
 require 'ffi/callback'
+require 'ffi/io'
+require 'ffi/autopointer'
+require 'ffi/variadic'
 
 module FFI
-  TypeDefs = Hash.new
-  def self.add_typedef(current, add)
-    if current.kind_of? Integer
-      code = current
-    else
-      code = TypeDefs[current]
-      raise TypeError, "Unable to resolve type '#{current}'" unless code
-    end
-
-    TypeDefs[add] = code
-  end
-  def self.find_type(name)
-    code = TypeDefs[name]
-    code = name if !code && name.kind_of?(Integer)
-    code = name if !code && name.kind_of?(FFI::Callback)
-    raise TypeError, "Unable to resolve type '#{name}'" unless code
-    return code
-  end
-  
-  # Converts a char
-  add_typedef(NativeType::INT8, :char)
-
-  # Converts an unsigned char
-  add_typedef(NativeType::UINT8, :uchar)
-  
-  # Converts an 8 bit int
-  add_typedef(NativeType::INT8, :int8)
-
-  # Converts an unsigned char
-  add_typedef(NativeType::UINT8, :uint8)
-
-  # Converts a short
-  add_typedef(NativeType::INT16, :short)
-
-  # Converts an unsigned short
-  add_typedef(NativeType::UINT16, :ushort)
-  
-  # Converts a 16bit int
-  add_typedef(NativeType::INT16, :int16)
-
-  # Converts an unsigned 16 bit int
-  add_typedef(NativeType::UINT16, :uint16)
-
-  # Converts an int
-  add_typedef(NativeType::INT32, :int)
-
-  # Converts an unsigned int
-  add_typedef(NativeType::UINT32, :uint)
-  
-  # Converts a 32 bit int
-  add_typedef(NativeType::INT32, :int32)
-
-  # Converts an unsigned 16 bit int
-  add_typedef(NativeType::UINT32, :uint32)
-
-  # Converts a long
-  add_typedef(NativeType::LONG, :long)
-
-  # Converts an unsigned long
-  add_typedef(NativeType::ULONG, :ulong)
-  
-  # Converts a 64 bit int
-  add_typedef(NativeType::INT64, :int64)
-
-  # Converts an unsigned 64 bit int
-  add_typedef(NativeType::UINT64, :uint64)
-
-  # Converts a long long
-  add_typedef(NativeType::INT64, :long_long)
-
-  # Converts an unsigned long long
-  add_typedef(NativeType::UINT64, :ulong_long)
-
-  # Converts a float
-  add_typedef(NativeType::FLOAT32, :float)
-
-  # Converts a double
-  add_typedef(NativeType::FLOAT64, :double)
-
-  # Converts a pointer to opaque data
-  add_typedef(NativeType::POINTER, :pointer)
-
-  # For when a function has no return value
-  add_typedef(NativeType::VOID, :void)
-
-  # Converts NUL-terminated C strings
-  add_typedef(NativeType::STRING, :string)
-  
-  # Use for a C struct with a char [] embedded inside.
-  add_typedef(NativeType::CHAR_ARRAY, :char_array)
-  
-  TypeSizes = {
-    1 => :char,
-    2 => :short,
-    4 => :int,
-    8 => :long_long,
-  }
   
-  SizeTypes = {
-    NativeType::INT8 => 1,
-    NativeType::UINT8 => 1,
-    NativeType::INT16 => 2,
-    NativeType::UINT16 => 2,
-    NativeType::INT32 => 4,
-    NativeType::UINT32 => 4,
-    NativeType::INT64 => 8,
-    NativeType::UINT64 => 8,
-    NativeType::FLOAT32 => 4,
-    NativeType::FLOAT64 => 8,
-    NativeType::LONG => FFI::Platform::LONG_SIZE / 8,
-    NativeType::ULONG => FFI::Platform::LONG_SIZE / 8,
-    NativeType::POINTER => FFI::Platform::ADDRESS_SIZE / 8,
-  }
-  def self.type_size(type)
-    if sz = SizeTypes[find_type(type)]
-      return sz
-    end
-    raise ArgumentError, "Unknown native type"
-  end
-  def self.create_invoker(lib, name, args, ret, convention = :default)    
+  def self.map_library_name(lib)
     # Mangle the library name to reflect the native library naming conventions
-    if lib
+    lib = Platform::LIBC if Platform::IS_LINUX && lib == 'c'
+    if lib && File.basename(lib) == lib
+      ext = ".#{Platform::LIBSUFFIX}"
       lib = Platform::LIBPREFIX + lib unless lib =~ /^#{Platform::LIBPREFIX}/
-      lib += Platform::LIBSUFFIX unless lib =~ /#{Platform::LIBSUFFIX}/
+      lib += ext unless lib =~ /#{ext}/
     end
+    lib
+  end
+  def self.create_invoker(lib, name, args, ret, options = { :convention => :default })
     # Current artificial limitation based on JRuby::FFI limit
     raise SignatureError, 'FFI functions may take max 32 arguments!' if args.size > 32
-        
-    invoker = FFI::Invoker.new(lib, name, args.map { |e| find_type(e) },
-      find_type(ret), convention.to_s)
-    raise NotFoundError.new(name, lib) unless invoker
-    return invoker
-  end
-end
 
-module FFI::Library
-  # TODO: Rubinius does *names here and saves the array. Multiple libs?
-  def ffi_lib(name)
-    @ffi_lib = name
-  end
-  def ffi_convention(convention)
-    @ffi_convention = convention
-  end
-  ##
-  # Attach C function +name+ to this module.
-  #
-  # If you want to provide an alternate name for the module function, supply
-  # it after the +name+, otherwise the C function name will be used.#
-  #
-  # After the +name+, the C function argument types are provided as an Array.
-  #
-  # The C function return type is provided last.
+    # Open the library if needed
+    library = if lib.kind_of?(DynamicLibrary)
+      lib
+    elsif lib.kind_of?(String)
+      # Allow FFI.create_invoker to be  called with a library name
+      DynamicLibrary.open(FFI.map_library_name(lib), DynamicLibrary::RTLD_LAZY)
+    elsif lib.nil?
+      FFI::Library::DEFAULT
+    else
+      raise LoadError, "Invalid library '#{lib}'"
+    end
+    function = library.find_symbol(name)
+    raise NotFoundError.new(name, library.name) unless function
 
-  def attach_function(mname, a3, a4, a5=nil)
-    cname, arg_types, ret_type = a5 ? [ a3, a4, a5 ] : [ mname.to_s, a3, a4 ]
-    lib = @ffi_lib
-    convention = @ffi_convention ? @ffi_convention : :default
-    # Convert :foo to the native type
-    arg_types.map! { |e|
-      begin
-        FFI.find_type(e)
-      rescue FFI::TypeError
-        @ffi_callbacks[e] || e
-      end
-    }
-    invoker = FFI.create_invoker lib, cname.to_s, arg_types, ret_type, convention    
-    raise ArgumentError, "Unable to find function '#{cname}' to bind to #{self.name}.#{mname}" unless invoker
-    #
-    # Attach the invoker to this module as 'mname'.
-    #
-    self.module_eval <<-code
-      @ffi_invoker_#{mname} = invoker
-      def self.#{mname}(*args, &block)
-        @ffi_invoker_#{mname}.call(*args, &block)
-      end
-    code
-    invoker
-  end
-  def callback(name, args, ret)
-    @ffi_callbacks = Hash.new unless @ffi_callbacks
-    @ffi_callbacks[name] = FFI::Callback.new(FFI.find_type(ret), args.map { |e| FFI.find_type(e) })
+    args = args.map {|e| find_type(e) }
+    if args.length > 0 && args[args.length - 1] == FFI::NativeType::VARARGS
+      invoker = FFI::VariadicInvoker.new(library, function, args, find_type(ret), options)
+    else
+      invoker = FFI::Invoker.new(library, function, args, find_type(ret), options[:convention].to_s)
+    end
+    raise NotFoundError.new(name, library.name) unless invoker
+    return invoker
   end
 end
-