ffi 1.10.0

data/lib/ffi/struct_layout_builder.rb

@@ -0,0 +1,227 @@
+#
+# 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
+
+  # Build a {StructLayout struct layout}.
+  class StructLayoutBuilder
+    attr_reader :size
+    attr_reader :alignment
+
+    def initialize
+      @size = 0
+      @alignment = 1
+      @min_alignment = 1
+      @packed = false
+      @union = false
+      @fields = Array.new
+    end
+
+    # Set size attribute with +size+ only if +size+ is greater than attribute value.
+    # @param [Numeric] size
+    def size=(size)
+      @size = size if size > @size
+    end
+
+    # Set alignment attribute with +align+ only if it is greater than attribute value.
+    # @param [Numeric] align
+    def alignment=(align)
+      @alignment = align if align > @alignment
+      @min_alignment = align
+    end
+
+    # Set union attribute.
+    # Set to +true+ to build a {Union} instead of a {Struct}.
+    # @param [Boolean] is_union
+    # @return [is_union]
+    def union=(is_union)
+      @union = is_union
+    end
+
+    # Building a {Union} or a {Struct} ?
+    #
+    # @return [Boolean]
+    #
+    def union?
+      @union
+    end
+
+    # Set packed attribute
+    # @overload packed=(packed) Set alignment and packed attributes to
+    #   +packed+.
+    #
+    #   @param [Fixnum] packed
+    #
+    #   @return [packed]
+    # @overload packed=(packed) Set packed attribute.
+    #   @param packed
+    #
+    #   @return [0,1]
+    #
+    def packed=(packed)
+      if packed.is_a?(0.class)
+        @alignment = packed
+        @packed = packed
+      else
+        @packed = packed ? 1 : 0
+      end
+    end
+
+
+    # List of number types
+    NUMBER_TYPES = [
+      Type::INT8,
+      Type::UINT8,
+      Type::INT16,
+      Type::UINT16,
+      Type::INT32,
+      Type::UINT32,
+      Type::LONG,
+      Type::ULONG,
+      Type::INT64,
+      Type::UINT64,
+      Type::FLOAT32,
+      Type::FLOAT64,
+      Type::LONGDOUBLE,
+      Type::BOOL,
+    ]
+
+    # @param [String, Symbol] name name of the field
+    # @param [Array, DataConverter, Struct, StructLayout::Field, Symbol, Type] type type of the field
+    # @param [Numeric, nil] offset
+    # @return [self]
+    # Add a field to the builder.
+    # @note Setting +offset+ to +nil+ or +-1+ is equivalent to +0+.
+    def add(name, type, offset = nil)
+
+      if offset.nil? || offset == -1
+        offset = @union ? 0 : align(@size, @packed ? [ @packed, type.alignment ].min : [ @min_alignment, type.alignment ].max)
+      end
+
+      #
+      # If a FFI::Type type was passed in as the field arg, try and convert to a StructLayout::Field instance
+      #
+      field = type.is_a?(StructLayout::Field) ? type : field_for_type(name, offset, type)
+      @fields << field
+      @alignment = [ @alignment, field.alignment ].max unless @packed
+      @size = [ @size, field.size + (@union ? 0 : field.offset) ].max
+
+      return self
+    end
+
+    # @param (see #add)
+    # @return (see #add)
+    # Same as {#add}.
+    # @see #add
+    def add_field(name, type, offset = nil)
+      add(name, type, offset)
+    end
+
+    # @param (see #add)
+    # @return (see #add)
+    # Add a struct as a field to the builder.
+    def add_struct(name, type, offset = nil)
+      add(name, Type::Struct.new(type), offset)
+    end
+
+    # @param name (see #add)
+    # @param type (see #add)
+    # @param [Numeric] count array length
+    # @param offset (see #add)
+    # @return (see #add)
+    # Add an array as a field to the builder.
+    def add_array(name, type, count, offset = nil)
+      add(name, Type::Array.new(type, count), offset)
+    end
+
+    # @return [StructLayout]
+    # Build and return the struct layout.
+    def build
+      # Add tail padding if the struct is not packed
+      size = @packed ? @size : align(@size, @alignment)
+
+      layout = StructLayout.new(@fields, size, @alignment)
+      layout.__union! if @union
+      layout
+    end
+
+    private
+
+    # @param [Numeric] offset
+    # @param [Numeric] align
+    # @return [Numeric]
+    def align(offset, align)
+      align + ((offset - 1) & ~(align - 1));
+    end
+
+    # @param (see #add)
+    # @return [StructLayout::Field]
+    def field_for_type(name, offset, type)
+      field_class = case
+      when type.is_a?(Type::Function)
+        StructLayout::Function
+
+      when type.is_a?(Type::Struct)
+        StructLayout::InnerStruct
+
+      when type.is_a?(Type::Array)
+        StructLayout::Array
+
+      when type.is_a?(FFI::Enum)
+        StructLayout::Enum
+
+      when NUMBER_TYPES.include?(type)
+        StructLayout::Number
+
+      when type == Type::POINTER
+        StructLayout::Pointer
+
+      when type == Type::STRING
+        StructLayout::String
+
+      when type.is_a?(Class) && type < StructLayout::Field
+        type
+
+      when type.is_a?(DataConverter)
+        return StructLayout::Mapped.new(name, offset, Type::Mapped.new(type), field_for_type(name, offset, type.native_type))
+
+      when type.is_a?(Type::Mapped)
+        return StructLayout::Mapped.new(name, offset, type, field_for_type(name, offset, type.native_type))
+
+      else
+        raise TypeError, "invalid struct field type #{type.inspect}"
+      end
+
+      field_class.new(name, offset, type)
+    end
+  end
+
+end

data/lib/ffi/tools/const_generator.rb

@@ -0,0 +1,229 @@
+require 'tempfile'
+require 'open3'
+
+module FFI
+
+  # ConstGenerator turns C constants into ruby values.
+  #
+  # @example a simple example for stdio
+  #  cg = FFI::ConstGenerator.new('stdio') do |gen|
+  #    gen.const(:SEEK_SET)
+  #    gen.const('SEEK_CUR')
+  #    gen.const('seek_end')   # this constant does not exist
+  #  end            # #calculate called automatically at the end of the block
+  #
+  #  cg['SEEK_SET'] # => 0
+  #  cg['SEEK_CUR'] # => 1
+  #  cg['seek_end'] # => nil
+  #  cg.to_ruby     # => "SEEK_SET = 0\nSEEK_CUR = 1\n# seek_end not available"
+  class ConstGenerator
+    @options = {}
+    attr_reader :constants
+
+    # Creates a new constant generator that uses +prefix+ as a name, and an
+    # options hash.
+    #
+    # The only option is +:required+, which if set to +true+ raises an error if a
+    # constant you have requested was not found.
+    # 
+    # @param [#to_s] prefix
+    # @param [Hash] options
+    # @return 
+    # @option options [Boolean] :required
+    # @overload initialize(prefix, options)
+    # @overload initialize(prefix, options) { |gen| ... }
+    #  @yieldparam [ConstGenerator] gen new generator is passed to the block
+    #  When passed a block, {#calculate} is automatically called at the end of
+    #  the block, otherwise you must call it yourself.
+    def initialize(prefix = nil, options = {})
+      @includes = ['stdio.h', 'stddef.h']
+      @constants = {}
+      @prefix = prefix
+
+      @required = options[:required]
+      @options = options
+
+      if block_given? then
+        yield self
+        calculate self.class.options.merge(options)
+      end
+    end
+    # Set class options
+    # These options are merged with {#initialize} options when it is called with a block.
+    # @param [Hash] options
+    # @return [Hash] class options
+    def self.options=(options)
+      @options = options
+    end
+    # Get class options.
+    # @return [Hash] class options
+    def self.options
+      @options
+    end
+    # @param [String] name
+    # @return constant value (converted if a +converter+ was defined).
+    # Access a constant by name.
+    def [](name)
+      @constants[name].converted_value
+    end
+
+    # Request the value for C constant +name+.
+    #
+    # @param [#to_s] name C constant name
+    # @param [String] format a printf format string to print the value out
+    # @param [String] cast a C cast for the value
+    # @param ruby_name alternate ruby name for {#to_ruby}
+    #
+    # @overload const(name, format=nil, cast='', ruby_name=nil, converter=nil)
+    #  +converter+ is a Method or a Proc.
+    #  @param [#call] converter convert the value from a string to the appropriate
+    #   type for {#to_ruby}.
+    # @overload const(name, format=nil, cast='', ruby_name=nil) { |value| ... }
+    #  Use a converter block. This block convert the value from a string to the 
+    #  appropriate type for {#to_ruby}.
+    #  @yieldparam value constant value
+    def const(name, format = nil, cast = '', ruby_name = nil, converter = nil,
+              &converter_proc)
+      format ||= '%d'
+      cast ||= ''
+
+      if converter_proc and converter then
+        raise ArgumentError, "Supply only converter or converter block"
+      end
+
+      converter = converter_proc if converter.nil?
+
+      const = Constant.new name, format, cast, ruby_name, converter
+      @constants[name.to_s] = const
+      return const
+    end
+
+    # Calculate constants values.
+    # @param [Hash] options
+    # @option options [String] :cppflags flags for C compiler
+    # @return [nil]
+    # @raise if a constant is missing and +:required+ was set to +true+ (see {#initialize})
+    def calculate(options = {})
+      binary = File.join Dir.tmpdir, "rb_const_gen_bin_#{Process.pid}"
+
+      Tempfile.open("#{@prefix}.const_generator") do |f|
+        @includes.each do |inc|
+          f.puts "#include <#{inc}>"
+        end
+        f.puts "\nint main(int argc, char **argv)\n{"
+
+        @constants.each_value do |const|
+          f.puts <<-EOF
+  #ifdef #{const.name}
+  printf("#{const.name} #{const.format}\\n", #{const.cast}#{const.name});
+  #endif
+          EOF
+        end
+
+        f.puts "\n\treturn 0;\n}"
+        f.flush
+
+        output = `gcc #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -x c -Wall -Werror #{f.path} -o #{binary} 2>&1`
+
+        unless $?.success? then
+          output = output.split("\n").map { |l| "\t#{l}" }.join "\n"
+          raise "Compilation error generating constants #{@prefix}:\n#{output}"
+        end
+      end
+
+      output = `#{binary}`
+      File.unlink(binary + (FFI::Platform.windows? ? ".exe" : ""))
+      output.each_line do |line|
+        line =~ /^(\S+)\s(.*)$/
+        const = @constants[$1]
+        const.value = $2
+      end
+
+      missing_constants = @constants.select do |name, constant|
+        constant.value.nil?
+      end.map { |name,| name }
+
+      if @required and not missing_constants.empty? then
+        raise "Missing required constants for #{@prefix}: #{missing_constants.join ', '}"
+      end
+    end
+
+    # Dump constants to +io+.
+    # @param [#puts] io
+    # @return [nil]
+    def dump_constants(io)
+      @constants.each do |name, constant|
+        name = [@prefix, name].join '.' if @prefix
+        io.puts "#{name} = #{constant.converted_value}"
+      end
+    end
+
+    # Outputs values for discovered constants.  If the constant's value was
+    # not discovered it is not omitted.
+    # @return [String]
+    def to_ruby
+      @constants.sort_by { |name,| name }.map do |name, constant|
+        if constant.value.nil? then
+          "# #{name} not available"
+        else
+          constant.to_ruby
+        end
+      end.join "\n"
+    end
+
+    # Add additional C include file(s) to calculate constants from.
+    # @note +stdio.h+ and +stddef.h+ automatically included
+    # @param [List<String>, Array<String>] i include file(s)
+    # @return [Array<String>] array of include files
+    def include(*i)
+      @includes |= i.flatten
+    end
+
+  end
+
+  # This class hold constants for {ConstGenerator}
+  class ConstGenerator::Constant
+
+    attr_reader :name, :format, :cast
+    attr_accessor :value
+
+    # @param [#to_s] name
+    # @param [String] format a printf format string to print the value out
+    # @param [String] cast a C cast for the value
+    # @param ruby_name alternate ruby name for {#to_ruby}
+    # @param [#call] converter convert the value from a string to the appropriate
+    #  type for {#to_ruby}.
+    def initialize(name, format, cast, ruby_name = nil, converter=nil)
+      @name = name
+      @format = format
+      @cast = cast
+      @ruby_name = ruby_name
+      @converter = converter
+      @value = nil
+    end
+
+    # Return constant value (converted if a +converter+ was defined).
+    # @return constant value.
+    def converted_value
+      if @converter
+        @converter.call(@value)
+      else
+        @value
+      end
+    end
+
+    # get constant ruby name
+    # @return [String]
+    def ruby_name
+      @ruby_name || @name
+    end
+
+    # Get an evaluable string from constant.
+    # @return [String]
+    def to_ruby
+      "#{ruby_name} = #{converted_value}"
+    end
+
+  end  
+
+end