ffi 1.12.2-java → 1.14.2-java

data/lib/ffi/tools/generator.rb

@@ -0,0 +1,105 @@
+require 'ffi/tools/struct_generator'
+require 'ffi/tools/const_generator'
+
+module FFI
+
+  ##
+  # Generate files with C structs for FFI::Struct and C constants.
+  #
+  # == A simple example
+  #
+  # In file +zlib.rb.ffi+:
+  #   module Zlib
+  #     @@@
+  #     constants do |c|
+  #       c.include "zlib.h"
+  #       c.const :ZLIB_VERNUM
+  #     end
+  #     @@@
+  #
+  #     class ZStream < FFI::Struct
+  #
+  #       struct do |s|
+  #         s.name "struct z_stream_s"
+  #         s.include "zlib.h"
+  #
+  #         s.field :next_in,   :pointer
+  #         s.field :avail_in,  :uint
+  #         s.field :total_in,  :ulong
+  #       end
+  #       @@@
+  #     end
+  #   end
+  #
+  # Translate the file:
+  #   require "ffi/tools/generator"
+  #   FFI::Generator.new "zlib.rb.ffi", "zlib.rb"
+  #
+  # Generates the file +zlib.rb+ with constant values and offsets:
+  #   module Zlib
+  #   ZLIB_VERNUM = 4784
+  #
+  #   class ZStream < FFI::Struct
+  #     layout :next_in, :pointer, 0,
+  #            :avail_in, :uint, 8,
+  #            :total_in, :ulong, 16
+  #   end
+  #
+  # @see FFI::Generator::Task for easy integration in a Rakefile
+  class Generator
+
+    def initialize(ffi_name, rb_name, options = {})
+      @ffi_name = ffi_name
+      @rb_name = rb_name
+      @options = options
+      @name = File.basename rb_name, '.rb'
+
+      file = File.read @ffi_name
+
+      new_file = file.gsub(/^( *)@@@(.*?)@@@/m) do
+        @constants = []
+        @structs = []
+
+        indent = $1
+        original_lines = $2.count "\n"
+
+        instance_eval $2, @ffi_name, $`.count("\n")
+
+        new_lines = []
+        @constants.each { |c| new_lines << c.to_ruby }
+        @structs.each { |s| new_lines << s.generate_layout }
+
+        new_lines = new_lines.join("\n").split "\n" # expand multiline blocks
+        new_lines = new_lines.map { |line| indent + line }
+
+        padding = original_lines - new_lines.length
+        new_lines += [nil] * padding if padding >= 0
+
+        new_lines.join "\n"
+      end
+
+      open @rb_name, 'w' do |f|
+        f.puts "# This file is generated from `#{@ffi_name}'. Do not edit."
+        f.puts
+        f.puts new_file
+      end
+    end
+
+    def constants(options = {}, &block)
+      @constants << FFI::ConstGenerator.new(@name, @options.merge(options), &block)
+    end
+
+    def struct(options = {}, &block)
+      @structs << FFI::StructGenerator.new(@name, @options.merge(options), &block)
+    end
+
+    ##
+    # Utility converter for constants
+
+    def to_s
+      proc { |obj| obj.to_s.inspect }
+    end
+
+  end
+end
+

data/lib/ffi/tools/generator_task.rb

@@ -0,0 +1,32 @@
+require 'ffi/tools/generator'
+require 'rake'
+require 'rake/tasklib'
+
+##
+# Add Rake tasks that generate files with C structs for FFI::Struct and C constants.
+#
+# @example a simple example for your Rakefile
+#   require "ffi/tools/generator_task"
+#   # Add a task to generate my_object.rb out of my_object.rb.ffi
+#   FFI::Generator::Task.new ["my_object.rb"], cflags: "-I/usr/local/mylibrary"
+#
+# The generated files are also added to the 'clear' task.
+#
+# @see FFI::Generator for a description of the file content
+class FFI::Generator::Task < Rake::TaskLib
+
+  def initialize(rb_names, options={})
+    task :clean do rm_f rb_names end
+
+    rb_names.each do |rb_name|
+      ffi_name = "#{rb_name}.ffi"
+
+      file rb_name => ffi_name do |t|
+        puts "Generating #{rb_name}..." if Rake.application.options.trace
+
+        FFI::Generator.new ffi_name, rb_name, options
+      end
+    end
+  end
+
+end

data/lib/ffi/tools/struct_generator.rb

@@ -0,0 +1,194 @@
+require 'tempfile'
+
+module FFI
+
+  ##
+  # Generates an FFI Struct layout.
+  #
+  # Given the @@@ portion in:
+  #
+  #   class Zlib::ZStream < FFI::Struct
+  #     @@@
+  #     name "struct z_stream_s"
+  #     include "zlib.h"
+  #
+  #     field :next_in,   :pointer
+  #     field :avail_in,  :uint
+  #     field :total_in,  :ulong
+  #
+  #     # ...
+  #     @@@
+  #   end
+  #
+  # StructGenerator will create the layout:
+  #
+  #   layout :next_in, :pointer, 0,
+  #          :avail_in, :uint, 4,
+  #          :total_in, :ulong, 8,
+  #          # ...
+  #
+  # StructGenerator does its best to pad the layout it produces to preserve
+  # line numbers.  Place the struct definition as close to the top of the file
+  # for best results.
+
+  class StructGenerator
+    @options = {}
+    attr_accessor :size
+    attr_reader   :fields
+
+    def initialize(name, options = {})
+      @name = name
+      @struct_name = nil
+      @includes = []
+      @fields = []
+      @found = false
+      @size = nil
+
+      if block_given? then
+        yield self
+        calculate self.class.options.merge(options)
+      end
+    end
+    def self.options=(options)
+      @options = options
+    end
+    def self.options
+      @options
+    end
+    def calculate(options = {})
+      binary = File.join Dir.tmpdir, "rb_struct_gen_bin_#{Process.pid}"
+
+      raise "struct name not set" if @struct_name.nil?
+
+      Tempfile.open("#{@name}.struct_generator") do |f|
+        f.puts "#include <stdio.h>"
+
+        @includes.each do |inc|
+          f.puts "#include <#{inc}>"
+        end
+
+        f.puts "#include <stddef.h>\n\n"
+        f.puts "int main(int argc, char **argv)\n{"
+        f.puts "  #{@struct_name} s;"
+        f.puts %[  printf("sizeof(#{@struct_name}) %u\\n", (unsigned int) sizeof(#{@struct_name}));]
+
+        @fields.each do |field|
+          f.puts <<-EOF
+    printf("#{field.name} %u %u\\n", (unsigned int) offsetof(#{@struct_name}, #{field.name}),
+           (unsigned int) sizeof(s.#{field.name}));
+  EOF
+        end
+
+        f.puts "\n  return 0;\n}"
+        f.flush
+
+        output = `gcc #{options[:cppflags]} #{options[:cflags]} -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
+          @found = false
+          output = output.split("\n").map { |l| "\t#{l}" }.join "\n"
+          raise "Compilation error generating struct #{@name} (#{@struct_name}):\n#{output}"
+        end
+      end
+
+      output = `#{binary}`.split "\n"
+      File.unlink(binary + (FFI::Platform.windows? ? ".exe" : ""))
+      sizeof = output.shift
+      unless @size
+        m = /\s*sizeof\([^)]+\) (\d+)/.match sizeof
+        @size = m[1]
+      end
+
+      line_no = 0
+      output.each do |line|
+        md = line.match(/.+ (\d+) (\d+)/)
+        @fields[line_no].offset = md[1].to_i
+        @fields[line_no].size   = md[2].to_i
+
+        line_no += 1
+      end
+
+      @found = true
+    end
+
+    def field(name, type=nil)
+      field = Field.new(name, type)
+      @fields << field
+      return field
+    end
+
+    def found?
+      @found
+    end
+
+    def dump_config(io)
+      io.puts "rbx.platform.#{@name}.sizeof = #{@size}"
+
+      @fields.each { |field| io.puts field.to_config(@name) }
+    end
+
+    def generate_layout
+      buf = ""
+
+      @fields.each_with_index do |field, i|
+        if buf.empty?
+          buf << "layout :#{field.name}, :#{field.type}, #{field.offset}"
+        else
+          buf << "       :#{field.name}, :#{field.type}, #{field.offset}"
+        end
+
+        if i < @fields.length - 1
+          buf << ",\n"
+        end
+      end
+
+      buf
+    end
+
+    def get_field(name)
+      @fields.find { |f| name == f.name }
+    end
+
+    def include(i)
+      @includes << i
+    end
+
+    def name(n)
+      @struct_name = n
+    end
+
+  end
+
+  ##
+  # A field in a Struct.
+
+  class StructGenerator::Field
+
+    attr_reader :name
+    attr_reader :type
+    attr_reader :offset
+    attr_accessor :size
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @offset = nil
+      @size = nil
+    end
+
+    def offset=(o)
+      @offset = o
+    end
+
+    def to_config(name)
+      buf = []
+      buf << "rbx.platform.#{name}.#{@name}.offset = #{@offset}"
+      buf << "rbx.platform.#{name}.#{@name}.size = #{@size}"
+      buf << "rbx.platform.#{name}.#{@name}.type = #{@type}" if @type
+      buf
+    end
+
+  end
+
+end
+

data/lib/ffi/tools/types_generator.rb

@@ -0,0 +1,137 @@
+require 'tempfile'
+
+module FFI
+
+  # @private
+  class TypesGenerator
+
+    ##
+    # Maps different C types to the C type representations we use
+
+    TYPE_MAP = {
+               "char" => :char,
+        "signed char" => :char,
+      "__signed char" => :char,
+      "unsigned char" => :uchar,
+
+               "short"     => :short,
+        "signed short"     => :short,
+        "signed short int" => :short,
+      "unsigned short"     => :ushort,
+      "unsigned short int" => :ushort,
+
+               "int" => :int,
+        "signed int" => :int,
+      "unsigned int" => :uint,
+
+               "long" => :long,
+               "long int" => :long,
+        "signed long" => :long,
+        "signed long int" => :long,
+      "unsigned long" => :ulong,
+      "unsigned long int" => :ulong,
+      "long unsigned int" => :ulong,
+
+               "long long"     => :long_long,
+               "long long int" => :long_long,
+        "signed long long"     => :long_long,
+        "signed long long int" => :long_long,
+      "unsigned long long"     => :ulong_long,
+      "unsigned long long int" => :ulong_long,
+
+      "char *" => :string,
+      "void *" => :pointer,
+    }
+
+    def self.generate(options = {})
+      typedefs = nil
+      Tempfile.open 'ffi_types_generator' do |io|
+        io.puts <<-C
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+#if !(defined(WIN32))
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/resource.h>
+#endif
+        C
+
+        io.close
+        cc = ENV['CC'] || 'gcc'
+        cmd = "#{cc} -E -x c #{options[:cppflags]} -D_DARWIN_USE_64_BIT_INODE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -c"
+        if options[:input]
+          typedefs = File.read(options[:input])
+        elsif options[:remote]
+          typedefs = `ssh #{options[:remote]} #{cmd} - < #{io.path}`
+        else
+          typedefs = `#{cmd} #{io.path}`
+        end
+      end
+
+      code = []
+
+      typedefs.each_line do |type|
+        # We only care about single line typedef
+        next unless type =~ /typedef/
+        # Ignore unions or structs
+        next if type =~ /union|struct/
+
+        # strip off the starting typedef and ending ;
+        type.gsub!(/^(.*typedef\s*)/, "")
+        type.gsub!(/\s*;\s*$/, "")
+
+        parts = type.split(/\s+/)
+        def_type   = parts.join(" ")
+
+        # GCC does mapping with __attribute__ stuf, also see
+        # http://hal.cs.berkeley.edu/cil/cil016.html section 16.2.7.  Problem
+        # with this is that the __attribute__ stuff can either occur before or
+        # after the new type that is defined...
+        if type =~ /__attribute__/
+          if parts.last =~ /__QI__|__HI__|__SI__|__DI__|__word__/
+
+            # In this case, the new type is BEFORE __attribute__ we need to
+            # find the final_type as the type before the part that starts with
+            # __attribute__
+            final_type = ""
+            parts.each do |p|
+              break if p =~ /__attribute__/
+              final_type = p
+            end
+          else
+            final_type = parts.pop
+          end
+
+          def_type = case type
+                     when /__QI__/   then "char"
+                     when /__HI__/   then "short"
+                     when /__SI__/   then "int"
+                     when /__DI__/   then "long long"
+                     when /__word__/ then "long"
+                     else                 "int"
+                     end
+
+          def_type = "unsigned #{def_type}" if type =~ /unsigned/
+        else
+          final_type = parts.pop
+          def_type   = parts.join(" ")
+        end
+
+        if type = TYPE_MAP[def_type]
+          code << "rbx.platform.typedef.#{final_type} = #{type}"
+          TYPE_MAP[final_type] = TYPE_MAP[def_type]
+        else
+          # Fallback to an ordinary pointer if we don't know the type
+          if def_type =~ /\*/
+            code << "rbx.platform.typedef.#{final_type} = pointer"
+            TYPE_MAP[final_type] = :pointer
+          end
+        end
+      end
+
+      code.sort.join("\n")
+    end
+  end
+end
+