ffi 0.5.0-x86-mingw32

data/ext/ffi_c/rbffi.h

@@ -0,0 +1,26 @@
+#ifndef _RBFFI_H
+#define	_RBFFI_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define MAX_PARAMETERS (32)
+
+extern VALUE rbffi_FFIModule;
+    
+extern void rbffi_Type_Init(VALUE ffiModule);
+extern void rbffi_Buffer_Init(VALUE ffiModule);
+extern void rbffi_Invoker_Init(VALUE ffiModule);
+extern void rbffi_Variadic_Init(VALUE ffiModule);
+extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
+extern int rbffi_type_size(VALUE type);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* _RBFFI_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') 
+file 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.rb

@@ -0,0 +1,11 @@
+begin
+  if RUBY_VERSION =~ /1.8/
+    require '1.8/ffi_c'
+  elsif RUBY_VERSION =~ /1.9/
+    require '1.9/ffi_c'
+  end
+rescue Exception
+  require 'ffi_c'
+end
+
+require 'ffi/ffi'

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 initialize(ptr, proc=nil, &block)
+      raise TypeError, "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
+                      AutoPointer.finalize(ptr, AutoPointer.method_to_proc(proc))
+                    elsif proc and proc.is_a? Proc
+                      AutoPointer.finalize(ptr, proc)
+                    else
+                      AutoPointer.finalize(ptr, AutoPointer.method_to_proc(self.class.method(:release)))
+                    end
+      self.parent = ptr
+      ObjectSpace.define_finalizer(self, free_lambda)
+      self
+    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/callback.rb

@@ -0,0 +1,10 @@
+module FFI
+  module Library
+    
+  end
+#  class Callback
+    #    def initialize
+    #
+    #    end
+#  end
+end

data/lib/ffi/enum.rb

@@ -0,0 +1,78 @@
+module FFI
+
+  class Enums
+
+    def initialize
+      @all_enums = Array.new
+      @tagged_enums = Hash.new
+      @symbol_map = Hash.new
+    end
+
+    def <<(enum)
+      @all_enums << enum
+      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
+      @symbol_map.merge!(enum.symbol_map)
+    end
+
+    def find(query)
+      if @tagged_enums.has_key?(query)
+        @tagged_enums[query]
+      else
+        @all_enums.detect { |enum| enum.symbols.include?(query) }
+      end
+    end
+
+    def __map_symbol(symbol)
+      @symbol_map[symbol]
+    end
+
+  end
+
+  class Enum
+    attr_reader :tag
+
+    def initialize(info, tag=nil)
+      @tag = tag
+      @kv_map = Hash.new
+      @vk_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            @kv_map[i] = value
+            @vk_map[value] = i
+            last_cst = i
+            value += 1
+          when Integer
+            @kv_map[last_cst] = i
+            @vk_map[i] = last_cst
+            value = i+1
+          end
+        end
+      end
+    end
+
+    def symbols
+      @kv_map.keys
+    end
+
+    def [](query)
+      case query
+      when Symbol
+        @kv_map[query]
+      when Integer
+        @vk_map[query]
+      end
+    end
+    alias find []
+
+    def symbol_map
+      @kv_map
+    end
+    alias to_h symbol_map
+
+  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

@@ -0,0 +1,99 @@
+#
+# Copyright (C) 2008 JRuby project
+# Copyright (c) 2007, 2008 Evan Phoenix
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Evan Phoenix nor the names of its contributors 
+#   may be used to endorse or promote products derived from this software 
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module FFI
+  #  Specialised error classes
+  class NativeError < LoadError; end
+  
+  class SignatureError < NativeError; end
+  
+  class NotFoundError < NativeError
+    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/union'
+require 'ffi/managedstruct'
+require 'ffi/callback'
+require 'ffi/io'
+require 'ffi/autopointer'
+require 'ffi/variadic'
+require 'ffi/enum'
+
+module FFI
+  
+  def self.map_library_name(lib)
+    # Mangle the library name to reflect the native library naming conventions
+    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 += ext unless lib =~ /#{ext}/
+    end
+    lib
+  end
+
+
+  def self.create_invoker(lib, name, args, ret_type, options = { :convention => :default })
+    # Current artificial limitation based on JRuby::FFI limit
+    raise SignatureError, 'FFI functions may take max 32 arguments!' if args.size > 32
+
+    # 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_function(name)
+    raise NotFoundError.new(name, library.name) unless function
+
+    args = args.map {|e| find_type(e) }
+    invoker = if args.length > 0 && args[args.length - 1] == FFI::NativeType::VARARGS
+      FFI::VariadicInvoker.new(function, args, find_type(ret_type), options)
+    else
+      FFI::Function.new(find_type(ret_type), args, function, options)
+    end
+    raise NotFoundError.new(name, library.name) unless invoker
+
+    return invoker
+  end
+end

data/lib/ffi/io.rb

@@ -0,0 +1,21 @@
+module FFI
+  module IO
+    def self.for_fd(fd, mode = "r")
+      ::IO.for_fd(fd, mode)
+    end
+
+    #
+    # A version of IO#read that reads into a native buffer
+    # 
+    # This will be optimized at some future time to eliminate the double copy
+    #
+    def self.native_read(io, buf, len)
+      tmp = io.read(len)
+      return -1 unless tmp
+      buf.put_bytes(0, tmp)
+      tmp.length
+    end
+
+  end
+end
+

data/lib/ffi/library.rb

@@ -0,0 +1,218 @@
+module FFI::Library
+  DEFAULT = FFI::DynamicLibrary.open(nil, FFI::DynamicLibrary::RTLD_LAZY)
+ 
+  def ffi_lib(*names)
+    ffi_libs = []
+    errors = {}
+    names.each do |name|
+      [ name, FFI.map_library_name(name) ].each do |libname|
+        begin
+          lib = FFI::DynamicLibrary.open(libname, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
+          if lib
+            ffi_libs << lib
+            break
+          end
+        rescue Exception => ex
+          errors[name] = ex
+        end
+      end
+    end
+    if ffi_libs.empty?
+      msgs = []
+      errors.each {|name, ex| msgs << "Failed to load library '#{name}': #{ex.message}" }
+      raise LoadError.new(msgs.join('\n'))
+    end
+
+    @ffi_libs = ffi_libs
+  end
+  def ffi_convention(convention)
+    @ffi_convention = convention
+  end
+
+  def ffi_libraries
+    unless defined?(@ffi_libs) or self.name.nil?
+      libs = []
+      # Try the exact name (e.g. User32) and all lower case (e.g. LibC -> libc)
+      [ self.name, self.name.downcase ].each do |name|
+        begin
+          libs << FFI::DynamicLibrary.open(name, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
+        rescue Exception
+        end
+      end
+      @ffi_libs = libs unless libs.empty?
+    end
+    defined?(@ffi_libs) ? @ffi_libs : [ DEFAULT ]
+  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.
+
+  def attach_function(mname, a3, a4, a5=nil)
+    cname, arg_types, ret_type = a5 ? [ a3, a4, a5 ] : [ mname.to_s, a3, a4 ]
+
+    # Convert :foo to the native type
+    arg_types.map! { |e| find_type(e) }
+    has_callback = arg_types.any? {|t| t.kind_of?(FFI::CallbackInfo)}
+    options = Hash.new
+    options[:convention] = defined?(@ffi_convention) ? @ffi_convention : :default
+    options[:type_map] = @ffi_typedefs if defined?(@ffi_typedefs)
+    options[:enums] = @ffi_enums if defined?(@ffi_enums)
+
+    # Try to locate the function in any of the libraries
+    invokers = []
+    ffi_libraries.each do |lib|
+      begin
+        invokers << FFI.create_invoker(lib, cname.to_s, arg_types, find_type(ret_type), options)
+      rescue LoadError => ex
+      end if invokers.empty?
+    end
+    invoker = invokers.compact.shift
+    raise FFI::NotFoundError.new(cname.to_s, ffi_libraries.map { |lib| lib.name }) unless invoker
+
+    # Setup the parameter list for the module function as (a1, a2)
+    arity = arg_types.length
+    params = (1..arity).map {|i| "a#{i}" }.join(",")
+
+    # Always use rest args for functions with callback parameters
+    if has_callback || invoker.kind_of?(FFI::VariadicInvoker)
+      params = "*args, &block"
+    end
+    call = arity <= 3 && !has_callback && !invoker.kind_of?(FFI::VariadicInvoker)? "call#{arity}" : "call"
+
+    #
+    # Attach the invoker to this module as 'mname'.
+    #
+    if !has_callback && !invoker.kind_of?(FFI::VariadicInvoker)
+      invoker.attach(self, mname.to_s)
+    else
+      self.module_eval <<-code
+        @@#{mname} = invoker
+        def self.#{mname}(#{params})
+          @@#{mname}.#{call}(#{params})
+        end
+        def #{mname}(#{params})
+          @@#{mname}.#{call}(#{params})
+        end
+      code
+    end
+    invoker
+  end
+  def attach_variable(mname, a1, a2 = nil)
+    cname, type = a2 ? [ a1, a2 ] : [ mname.to_s, a1 ]
+    address = nil
+    ffi_libraries.each do |lib|
+      begin
+        address = lib.find_variable(cname.to_s)
+        break unless address.nil?
+      rescue LoadError
+      end
+    end
+
+    raise FFI::NotFoundError.new(cname, ffi_libraries) if address.nil? || address.null?
+    s = FFI::Struct.new(address, :gvar, find_type(type))
+    
+    #
+    # Attach to this module as mname/mname=
+    #
+    self.module_eval <<-code
+      @@ffi_gvar_#{mname} = s
+      def self.#{mname}
+        @@ffi_gvar_#{mname}[:gvar]
+      end
+      def self.#{mname}=(value)
+        @@ffi_gvar_#{mname}[:gvar] = value
+      end
+    code
+    
+    address
+  end
+
+  def callback(*args)
+    raise ArgError, "wrong number of arguments" if args.length < 2 || args.length > 3
+    name, params, ret = if args.length == 3
+      args
+    else
+      [ nil, args[0], args[1] ]
+    end
+    cb = FFI::CallbackInfo.new(find_type(ret), params.map { |e| find_type(e) })
+
+    # Add to the symbol -> type map (unless there was no name)
+    unless name.nil?
+      @ffi_callbacks = Hash.new unless defined?(@ffi_callbacks)
+      @ffi_callbacks[name] = cb
+    end
+
+    cb
+  end
+  
+  def typedef(current, add, info=nil)
+    @ffi_typedefs = Hash.new unless defined?(@ffi_typedefs)
+    code = if current.kind_of?(FFI::Type)
+      current
+    elsif current == :enum
+      if add.kind_of?(Array)
+        self.enum(add)
+      else
+        self.enum(info, add)
+      end
+    else
+      @ffi_typedefs[current] || FFI.find_type(current)
+    end
+
+    @ffi_typedefs[add] = code
+  end
+
+  def enum(*args)
+    #
+    # enum can be called as:
+    # enum :zero, :one, :two  # unnamed enum
+    # enum [ :zero, :one, :two ] # equivalent to above
+    # enum :foo, [ :zero, :one, :two ] create an enum named :foo
+    #
+    name, values = if args[0].kind_of?(Symbol) && args[1].kind_of?(Array)
+      [ args[0], args[1] ]
+    elsif args[0].kind_of?(Array)
+      [ nil, args[0] ]
+    else
+      [ nil, args ]
+    end
+    @ffi_enums = FFI::Enums.new unless defined?(@ffi_enums)
+    @ffi_enums << (e = FFI::Enum.new(values, name))
+
+    # If called as enum :foo, [ :zero, :one, :two ], add a typedef alias
+    typedef(e, name) if name
+    e
+  end
+
+  def enum_type(name)
+    @ffi_enums.find(name) if defined?(@ffi_enums)
+  end
+
+  def enum_value(symbol)
+    @ffi_enums.__map_symbol(symbol)
+  end
+
+  def find_type(name)
+    code = if defined?(@ffi_typedefs) && @ffi_typedefs.has_key?(name)
+      @ffi_typedefs[name]
+    elsif defined?(@ffi_callbacks) && @ffi_callbacks.has_key?(name)
+      @ffi_callbacks[name]
+    elsif name.is_a?(Class) && name < FFI::Struct
+      FFI::NativeType::POINTER
+    elsif name.kind_of?(FFI::Type)
+      name
+    end
+    if code.nil? || code.kind_of?(Symbol)
+      FFI.find_type(name)
+    else
+      code
+    end
+  end
+end