ffi 1.17.0.rc1-x86_64-linux-gnu

data/lib/ffi/data_converter.rb

@@ -0,0 +1,67 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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
+  # This module is used to extend somes classes and give then a common API.
+  #
+  # Most of methods defined here must be overridden.
+  module DataConverter
+    # Get native type.
+    #
+    # @overload native_type(type)
+    #  @param [String, Symbol, Type] type
+    #  @return [Type]
+    #  Get native type from +type+.
+    #
+    # @overload native_type
+    #  @raise {NotImplementedError} This method must be overridden.
+    def native_type(type = nil)
+      if type
+        @native_type = FFI.find_type(type)
+      else
+        native_type = @native_type
+        unless native_type
+          raise NotImplementedError, 'native_type method not overridden and no native_type set'
+        end
+        native_type
+      end
+    end
+
+    # Convert to a native type.
+    def to_native(value, ctx)
+      value
+    end
+
+    # Convert from a native type.
+    def from_native(value, ctx)
+      value
+    end
+  end
+end

data/lib/ffi/dynamic_library.rb

@@ -0,0 +1,118 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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
+  class DynamicLibrary
+    SEARCH_PATH = []
+
+    # The following search paths are tried, if the library could not be loaded in the first attempt.
+    # They are only executed on Macos in the following order:
+    if FFI::Platform.mac?
+
+      # 1. Try library paths possibly defined in LD_LIBRARY_PATH DYLD_LIBRARY_PATH first.
+      # This is because dlopen doesn't respect LD_LIBRARY_PATH and DYLD_LIBRARY_PATH is deleted by SIP-protected binaries.
+      # See here for details: https://github.com/ffi/ffi/issues/923#issuecomment-1872565313
+      %w[LD_LIBRARY_PATH DYLD_LIBRARY_PATH].each do |custom_path|
+        SEARCH_PATH.concat ENV.fetch(custom_path,"").split(File::PATH_SEPARATOR)
+      end
+
+      # 2. Then on macos/arm64 try /opt/homebrew/lib, since this is a typical standard directory.
+      # FFI is often used together with homebrew, so that we hardcode the path for arm64 here.
+      if FFI::Platform::ARCH == 'aarch64'
+        SEARCH_PATH << '/opt/homebrew/lib'
+      end
+
+      # 3. Then try typical system directories starting with the /local/ directory first.
+      #
+      # /usr/local/lib is used by homebrow on x86_64.
+      # /opt/local/lib is used by MacPorts and Fink.
+      # /usr/lib is there, because it was always there.
+      SEARCH_PATH.concat %w[/opt/local/lib /usr/local/lib /usr/lib]
+    end
+
+    # On Linux the library lookup paths are usually defined through /etc/ld.so.conf, which can be changed at will with root permissions.
+    # Also LD_LIBRARY_PATH is respected by the dynamic loader, so that there's usually no need and no advantage to do a fallback handling.
+    #
+    # Windows has it's own library lookup logic, very different to what we do here.
+    # See: https://github.com/oneclick/rubyinstaller2/wiki/For-gem-developers#user-content-dll-loading
+
+    FFI.make_shareable(SEARCH_PATH)
+    SEARCH_PATH_MESSAGE = "Searched in <system library path>#{ SEARCH_PATH.map{|a| ', ' + a}.join }".freeze
+
+    def self.load_library(name, flags)
+      if name == FFI::CURRENT_PROCESS
+        FFI::DynamicLibrary.open(nil, RTLD_LAZY | RTLD_LOCAL)
+      else
+        flags ||= RTLD_LAZY | RTLD_LOCAL
+
+        libnames = (name.is_a?(::Array) ? name : [name])
+        libnames = libnames.map(&:to_s).map { |n| [n, FFI.map_library_name(n)].uniq }.flatten.compact
+        errors = []
+
+        libnames.each do |libname|
+          lib = try_load(libname, flags, errors)
+          return lib if lib
+
+          unless libname.start_with?("/")
+            SEARCH_PATH.each do |prefix|
+              path = "#{prefix}/#{libname}"
+              if File.exist?(path)
+                lib = try_load(path, flags, errors)
+                return lib if lib
+              end
+            end
+          end
+        end
+
+        raise LoadError, [*errors, SEARCH_PATH_MESSAGE].join(".\n")
+      end
+    end
+    private_class_method :load_library
+
+    def self.try_load(libname, flags, errors)
+      begin
+        lib = FFI::DynamicLibrary.open(libname, flags)
+        return lib if lib
+
+      # LoadError for C ext & JRuby, RuntimeError for TruffleRuby
+      rescue LoadError, RuntimeError => ex
+        if ex.message =~ /(([^ \t()])+\.so([^ \t:()])*):([ \t])*(invalid ELF header|file too short|invalid file format)/
+          if File.binread($1) =~ /(?:GROUP|INPUT) *\( *([^ \)]+)/
+            return try_load($1, flags, errors)
+          end
+        end
+
+        errors << ex
+        nil
+      end
+    end
+    private_class_method :try_load
+  end
+end

data/lib/ffi/enum.rb

@@ -0,0 +1,302 @@
+#
+# Copyright (C) 2009, 2010 Wayne Meissner
+# Copyright (C) 2009 Luc Heinrich
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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
+
+  # An instance of this class permits to manage {Enum}s. In fact, Enums is a collection of {Enum}s.
+  class Enums
+
+    def initialize
+      @all_enums = Array.new
+      @tagged_enums = Hash.new
+      @symbol_map = Hash.new
+    end
+
+    # @param [Enum] enum
+    # Add an {Enum} to the collection.
+    def <<(enum)
+      @all_enums << enum
+      @tagged_enums[enum.tag] = enum unless enum.tag.nil?
+      @symbol_map.merge!(enum.symbol_map)
+    end
+
+    # @param query enum tag or part of an enum name
+    # @return [Enum]
+    # Find a {Enum} in collection.
+    def find(query)
+      if @tagged_enums.has_key?(query)
+        @tagged_enums[query]
+      else
+        @all_enums.detect { |enum| enum.symbols.include?(query) }
+      end
+    end
+
+    # @param symbol a symbol to find in merge symbol maps of all enums.
+    # @return a symbol
+    def __map_symbol(symbol)
+      @symbol_map[symbol]
+    end
+
+  end
+
+  # Represents a C enum.
+  #
+  # For a C enum:
+  #  enum fruits {
+  #    apple,
+  #    banana,
+  #    orange,
+  #    pineapple
+  #  };
+  # are defined this vocabulary:
+  # * a _symbol_ is a word from the enumeration (ie. _apple_, by example);
+  # * a _value_ is the value of a symbol in the enumeration (by example, apple has value _0_ and banana _1_).
+  class Enum
+    include DataConverter
+
+    attr_reader :tag
+    attr_reader :native_type
+
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info
+    #   @param [nil, Symbol] tag enum tag
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Enum
+    #   @param [nil, Enumerable] info symbols and values for new Enum
+    #   @param [nil, Symbol] tag name of new Enum
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      info, @tag = *args
+      @kv_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            raise ArgumentError, "duplicate enum key" if @kv_map.has_key?(i)
+            @kv_map[i] = value
+            last_cst = i
+            value += 1
+          when Integer
+            @kv_map[last_cst] = i
+            value = i+1
+          end
+        end
+      end
+      @vk_map = @kv_map.invert
+    end
+
+    # @return [Array] enum symbol names
+    def symbols
+      @kv_map.keys
+    end
+
+    # Get a symbol or a value from the enum.
+    # @overload [](query)
+    #  Get enum value from symbol.
+    #  @param [Symbol] query
+    #  @return [Integer]
+    # @overload [](query)
+    #  Get enum symbol from value.
+    #  @param [Integer] query
+    #  @return [Symbol]
+    def [](query)
+      case query
+      when Symbol
+        @kv_map[query]
+      when Integer
+        @vk_map[query]
+      end
+    end
+    alias find []
+
+    # Get the symbol map.
+    # @return [Hash]
+    def symbol_map
+      @kv_map
+    end
+
+    alias to_h symbol_map
+    alias to_hash symbol_map
+
+    # @param [Symbol, Integer, #to_int] val
+    # @param ctx unused
+    # @return [Integer] value of a enum symbol
+    def to_native(val, ctx)
+      @kv_map[val] || if val.is_a?(Integer)
+        val
+      elsif val.respond_to?(:to_int)
+        val.to_int
+      else
+        raise ArgumentError, "invalid enum value, #{val.inspect}"
+      end
+    end
+
+    # @param val
+    # @return symbol name if it exists for +val+.
+    def from_native(val, ctx)
+      @vk_map[val] || val
+    end
+  end
+
+  # Represents a C enum whose values are power of 2
+  #
+  # @example
+  #  enum {
+  #    red = (1<<0),
+  #    green = (1<<1),
+  #    blue = (1<<2)
+  #  }
+  #
+  # Contrary to classical enums, bitmask values are usually combined
+  # when used.
+  class Bitmask < Enum
+
+    # @overload initialize(info, tag=nil)
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    # @overload initialize(native_type, info, tag=nil)
+    #   @param [FFI::Type] native_type Native type for new Bitmask
+    #   @param [nil, Enumerable] info symbols and bit rank for new Bitmask
+    #   @param [nil, Symbol] tag name of new Bitmask
+    def initialize(*args)
+      @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      @signed = [Type::INT8, Type::INT16, Type::INT32, Type::INT64].include?(@native_type)
+      info, @tag = *args
+      @kv_map = Hash.new
+      unless info.nil?
+        last_cst = nil
+        value = 0
+        info.each do |i|
+          case i
+          when Symbol
+            raise ArgumentError, "duplicate bitmask key" if @kv_map.has_key?(i)
+            @kv_map[i] = 1 << value
+            last_cst = i
+            value += 1
+          when Integer
+            raise ArgumentError, "bitmask index should be positive" if i<0
+            @kv_map[last_cst] = 1 << i
+            value = i+1
+          end
+        end
+      end
+      @vk_map = @kv_map.invert
+    end
+
+    # Get a symbol list or a value from the bitmask
+    # @overload [](*query)
+    #  Get bitmask value from symbol list
+    #  @param [Symbol] query
+    #  @return [Integer]
+    # @overload [](query)
+    #  Get bitmask value from symbol array
+    #  @param [Array<Symbol>] query
+    #  @return [Integer]
+    # @overload [](*query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Integer] query
+    #  @return [Array<Symbol>]
+    # @overload [](query)
+    #  Get a list of bitmask symbols corresponding to
+    #  the or reduction of a list of integer
+    #  @param [Array<Integer>] query
+    #  @return [Array<Symbol>]
+    def [](*query)
+      flat_query = query.flatten
+      raise ArgumentError, "query should be homogeneous, #{query.inspect}" unless flat_query.all? { |o| o.is_a?(Symbol) } || flat_query.all? { |o| o.is_a?(Integer) || o.respond_to?(:to_int) }
+      case flat_query[0]
+      when Symbol
+        flat_query.inject(0) do |val, o|
+          v = @kv_map[o]
+          if v then val | v else val end
+        end
+      when Integer, ->(o) { o.respond_to?(:to_int) }
+        val = flat_query.inject(0) { |mask, o| mask |= o.to_int }
+        @kv_map.select { |_, v| v & val != 0 }.keys
+      end
+    end
+
+    # Get the native value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Symbol, Integer, #to_int] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    # @overload to_native(query, ctx)
+    #  @param [Array<Symbol, Integer, #to_int>] query
+    #  @param ctx unused
+    #  @return [Integer] value of a bitmask
+    def to_native(query, ctx)
+      return 0 if query.nil?
+      flat_query = [query].flatten
+      res = flat_query.inject(0) do |val, o|
+        case o
+        when Symbol
+          v = @kv_map[o]
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}" unless v
+          val | v
+        when Integer
+          val | o
+        when ->(obj) { obj.respond_to?(:to_int) }
+          val | o.to_int
+        else
+          raise ArgumentError, "invalid bitmask value, #{o.inspect}"
+        end
+      end
+      # Take two's complement of positive values bigger than the max value
+      # for the type when native type is signed.
+      if @signed && res >= (1 << (@native_type.size * 8 - 1))
+        res = -(-res & ((1 << (@native_type.size * 8)) - 1))
+      end
+      res
+    end
+
+    # @param [Integer] val
+    # @param ctx unused
+    # @return [Array<Symbol, Integer>] list of symbol names corresponding to val, plus an optional remainder if some bits don't match any constant
+    def from_native(val, ctx)
+      flags = @kv_map.select { |_, v| v & val != 0 }
+      list = flags.keys
+      # force an unsigned value of the correct size
+      val &= (1 << (@native_type.size * 8)) - 1 if @signed
+      # If there are unmatch flags,
+      # return them in an integer,
+      # else information can be lost.
+      # Similar to Enum behavior.
+      remainder = val ^ flags.values.reduce(0, :|)
+      list.push remainder unless remainder == 0
+      return list
+    end
+  end
+end

data/lib/ffi/errno.rb

@@ -0,0 +1,43 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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
+  # @return (see FFI::LastError.error)
+  # @see FFI::LastError.error
+  def self.errno
+    FFI::LastError.error
+  end
+  # @param error (see FFI::LastError.error=)
+  # @return (see FFI::LastError.error=)
+  # @see FFI::LastError.error=
+  def self.errno=(error)
+    FFI::LastError.error = error
+  end
+end

data/lib/ffi/ffi.rb

@@ -0,0 +1,50 @@
+#
+# Copyright (C) 2008-2010 JRuby project
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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.
+
+require 'ffi/compat'
+require 'ffi/platform'
+require 'ffi/data_converter'
+require 'ffi/types'
+require 'ffi/library_path'
+require 'ffi/library'
+require 'ffi/errno'
+require 'ffi/abstract_memory'
+require 'ffi/pointer'
+require 'ffi/memorypointer'
+require 'ffi/struct'
+require 'ffi/union'
+require 'ffi/managedstruct'
+require 'ffi/callback'
+require 'ffi/io'
+require 'ffi/autopointer'
+require 'ffi/variadic'
+require 'ffi/enum'
+require 'ffi/version'
+require 'ffi/function'

data/lib/ffi/function.rb

@@ -0,0 +1,71 @@
+#
+# Copyright (C) 2008-2010 JRuby project
+#
+# This file is part of ruby-ffi.
+#
+# 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 Ruby FFI project 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
+  class Function
+    # Only MRI allows function type queries
+    if private_method_defined?(:type)
+      # Retrieve the return type of the function
+      #
+      # This method returns FFI type returned by the function.
+      #
+      # @return [FFI::Type]
+      def return_type
+        type.return_type
+      end
+
+      # Retrieve Array of parameter types
+      #
+      # This method returns an Array of FFI types accepted as function parameters.
+      #
+      # @return [Array<FFI::Type>]
+      def param_types
+        type.param_types
+      end
+    end
+
+    # Stash the Function in a module variable so it can be inspected by attached_functions.
+    # On CRuby it also ensures that it does not get garbage collected.
+    module RegisterAttach
+      def attach(mod, name)
+        funcs = mod.instance_variable_defined?("@ffi_functions") && mod.instance_variable_get("@ffi_functions")
+        unless funcs
+          funcs = {}
+          mod.instance_variable_set("@ffi_functions", funcs)
+        end
+        funcs[name.to_sym] = self
+        # Jump to the native attach method of CRuby, JRuby or Tuffleruby
+        super
+      end
+    end
+    private_constant :RegisterAttach
+    prepend RegisterAttach
+  end
+end