ffi-compiler 0.0.3 → 0.1.0

data/README.md

@@ -33,13 +33,13 @@ Example
 	long
 	example(void)
 	{
-	  return 0xdeadbeef;
+	    return 0xdeadbeef;
 	}
 
 ###### ext/Rakefile
-	require 'ffi-compiler/task'
+	require 'ffi-compiler/compile_task'
 	
-	FFI::Compiler::Task.new('example') do |c|
+	FFI::Compiler::CompileTask.new('example') do |c|
 	  c.have_header?('stdio.h', '/usr/local/include')
 	  c.have_func?('puts')
 	  c.have_library?('z')

data/ffi-compiler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'ffi-compiler'
-  s.version = '0.0.3'
+  s.version = '0.1.0'
   s.author = 'Wayne Meissner'
   s.email = 'wmeissner@gmail.com'
   s.homepage = 'http://wiki.github.com/ffi/ffi'

data/lib/ffi-compiler/compile_task.rb

@@ -0,0 +1,216 @@
+require 'rake'
+require 'rake/tasklib'
+require 'rake/clean'
+require 'ffi'
+require 'tmpdir'
+require 'rbconfig'
+require_relative 'platform'
+
+module FFI
+  module Compiler
+    DEFAULT_CFLAGS = %w(-fexceptions -O -fno-omit-frame-pointer -fno-strict-aliasing)
+    DEFAULT_LDFLAGS = %w(-fexceptions)
+
+    class CompileTask < Rake::TaskLib
+      attr_reader :cflags, :cxxflags, :ldflags, :libs, :platform
+
+      def initialize(name)
+        @name = File.basename(name)
+        @ext_dir = File.dirname(name)
+        @defines = []
+        @include_paths = []
+        @library_paths = []
+        @libraries = []
+        @headers = []
+        @functions = []
+        @cflags = DEFAULT_CFLAGS.dup
+        @cxxflags = DEFAULT_CFLAGS.dup
+        @ldflags = DEFAULT_LDFLAGS.dup
+        @libs = []
+        @platform = Platform.system
+        @exports = []
+
+        yield self if block_given?
+        define_task!
+      end
+
+      def have_func?(func)
+        main = <<-C_FILE
+        extern void #{func}();
+        int main(int argc, char **argv) { #{func}(); return 0; }
+        C_FILE
+
+        if try_compile(main)
+          @functions << func
+          return true
+        end
+        false
+      end
+
+      def have_header?(header, *paths)
+        try_header(header, @include_paths) || try_header(header, paths)
+      end
+
+      def have_library?(libname, *paths)
+        try_library(libname, paths: @library_paths) || try_library(libname, paths: paths)
+      end
+      
+      def have_library(lib, func = nil, headers = nil, &b)
+        try_library(lib, function: func, headers: headers, paths: @library_paths)
+      end
+      
+      def find_library(lib, func, *paths)
+        try_library(lib, function: func, paths: @library_paths) || try_library(libname, function: func, paths: paths)
+      end
+
+      def export(rb_file)
+        @exports << { :rb_file => rb_file, :header => File.join(@ext_dir, File.basename(rb_file).sub(/\.rb$/, '.h')) }
+      end
+
+      private
+      def define_task!
+        pic_flags = %w(-fPIC)
+        so_flags = []
+
+        if @platform.mac?
+          pic_flags = []
+          so_flags << '-bundle'
+
+        elsif @platform.name =~ /linux/
+          so_flags << "-shared -Wl,-soname,#{lib_name}"
+
+        else
+          so_flags << '-shared'
+        end
+        so_flags = so_flags.join(' ')
+
+        out_dir = "#{@platform.arch}-#{@platform.os}"
+        if @ext_dir != '.'
+          out_dir = File.join(@ext_dir, out_dir)
+        end
+
+        directory(out_dir)
+        CLOBBER.include(out_dir)
+
+        lib_name = File.join(out_dir, Platform.system.map_library_name(@name))
+
+        iflags = @include_paths.uniq.map { |p| "-I#{p}" }
+        defines = @functions.uniq.map { |f| "-DHAVE_#{f.upcase}=1" }
+        defines << @headers.uniq.map { |h| "-DHAVE_#{h.upcase.sub(/\./, '_')}=1" }
+
+        cflags = (@cflags + pic_flags + iflags + defines).join(' ')
+        cxxflags = (@cxxflags + @cflags + pic_flags + iflags + defines).join(' ')
+        ld_flags = (@library_paths.map { |path| "-L#{path}" } + @ldflags).join(' ')
+        libs = (@libraries.map { |l| "-l#{l}" } + @libs).join(' ')
+
+        src_files = FileList["#{@ext_dir}/**/*.{c,cpp}"]
+        obj_files = src_files.ext('.o').map { |f| File.join(out_dir, f.sub(/^#{@ext_dir}\//, '')) }
+        ld = src_files.detect { |f| f =~ /\.cpp$/ } ? cxx : cc
+
+        src_files.each do |src|
+          obj_file = File.join(out_dir, src.sub(/\.(c|cpp)$/, '.o').sub(/^#{@ext_dir}\//, ''))
+          if src =~ /\.c$/
+            file obj_file => [ src, File.dirname(obj_file) ] do |t|
+              sh "#{cc} #{cflags} -o #{t.name} -c #{t.prerequisites[0]}"
+            end
+
+          else
+            file obj_file => [ src, File.dirname(obj_file) ] do |t|
+              sh "#{cxx} #{cxxflags} -o #{t.name} -c #{t.prerequisites[0]}"
+            end
+          end
+
+          CLEAN.include(obj_file)
+        end
+
+        desc "Build dynamic library"
+        file lib_name => obj_files do |t|
+          sh "#{ld} #{so_flags} -o #{t.name} #{t.prerequisites.join(' ')} #{ld_flags} #{libs}"
+        end
+        CLEAN.include(lib_name)
+
+        @exports.each do |e|
+          desc "Export #{e[:rb_file]}"
+          file e[:header] => [ e[:rb_file] ] do |t|
+            ruby "-I#{File.join(File.dirname(__FILE__), 'fake_ffi')} #{File.join(File.dirname(__FILE__), 'exporter.rb')} #{t.prerequisites[0]} #{t.name}"
+          end
+
+          obj_files.each { |o| file o  => [ e[:header] ] }
+          CLEAN.include(e[:header])
+
+          desc "Export API headers"
+          task :api_headers => [ e[:header] ]
+        end
+
+        task :default => [ lib_name ]
+        task :package => [ :api_headers ]
+      end
+
+      def try_header(header, paths)
+        main = <<-C_FILE
+          #include <#{header}>
+          int main(int argc, char **argv) { return 0; }
+        C_FILE
+
+        if paths.empty? && try_compile(main)
+          @headers << header
+          return true
+        end
+
+        paths.each do |path|
+          if try_compile(main, "-I#{path}")
+            @include_paths << path
+            @headers << header
+            return true
+          end
+        end
+        false
+      end
+
+
+      def try_library(libname, options = {})
+        func = options[:function] || 'main'
+        paths = options[:paths] || ''
+        main = <<-C_FILE
+        #{(options[:headers] || []).map {|h| "#include <#{h}>"}.join('\n')}
+        extern int #{func}();
+        int main() { return #{func}(); }
+        C_FILE
+
+        if paths.empty? && try_compile(main)
+          @libraries << libname
+          return true
+        end
+
+        paths.each do |path|
+          if try_compile(main, "-L#{path}", "-l#{libname}")
+            @library_paths << path
+            @libraries << libname
+          end
+        end
+      end
+
+      def try_compile(src, *opts)
+        Dir.mktmpdir do |dir|
+          path = File.join(dir, 'ffi-test.c')
+          File.open(path, 'w') do |f|
+            f << src
+          end
+          begin
+            return system "#{cc} #{opts.join(' ')} -o #{File.join(dir, 'ffi-test')} #{path} >& /dev/null"
+          rescue
+            return false
+          end
+        end
+      end
+
+      def cc
+        @cc ||= (ENV['CC'] || RbConfig::CONFIG['CC'] || 'cc')
+      end
+
+      def cxx
+        @cxx ||= (ENV['CXX'] || RbConfig::CONFIG['CXX'] || 'c++')
+      end
+    end
+  end
+end

data/lib/ffi-compiler/export_task.rb

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/tasklib'
+require 'rake/clean'
+
+module FFI
+  module Compiler
+    class ExportTask < Rake::TaskLib
+
+      def initialize(rb_dir, out_dir, options = {})
+        @rb_dir = rb_dir
+        @out_dir = out_dir
+        @gem_spec = options[:gem_spec]
+        @exports = []
+        
+        if block_given?
+          yield self
+          define_tasks!
+        end
+      end
+
+      def export(rb_file)
+        @exports << { :rb_file => File.join(@rb_dir, rb_file), :header => File.join(@out_dir, File.basename(rb_file).sub(/\.rb$/, '.h')) }
+      end
+
+      def export_all
+        Dir["#@rb_dir/**/*rb"].each do |rb_file|
+          @exports << { :rb_file => rb_file, :header => File.join(@out_dir, File.basename(rb_file).sub(/\.rb$/, '.h')) }
+        end
+      end
+
+      private
+      def define_tasks!
+        @exports.each do |e|
+          file e[:header] => [ e[:rb_file] ] do |t|
+            ruby "-I#{File.join(File.dirname(__FILE__), 'fake_ffi')} #{File.join(File.dirname(__FILE__), 'exporter.rb')} #{t.prerequisites[0]} #{t.name}"
+          end
+          CLEAN.include(e[:header])
+
+          desc "Export API headers"
+          task :api_headers => [ e[:header] ]
+          @gem_spec.files << e[:header] unless @gem_spec.nil?
+        end
+
+        task :gem => [ :api_headers ] unless @gem_spec.nil?
+      end
+
+    end
+  end
+end

data/lib/ffi-compiler/exporter.rb

@@ -0,0 +1,4 @@
+require 'ffi'
+
+load ARGV[0]
+FFI.exporter.dump(ARGV[1])

data/lib/ffi-compiler/fake_ffi/ffi-compiler/loader.rb

@@ -0,0 +1,8 @@
+module FFI
+  module Compiler
+    module Loader
+      def self.find(*args)
+      end
+    end
+  end
+end

data/lib/ffi-compiler/fake_ffi/ffi.rb

@@ -0,0 +1,170 @@
+module FFI
+
+  def self.exporter=(exporter)
+    @@exporter = exporter
+  end
+  
+  def self.exporter
+    @@exporter
+  end
+  
+  class Type
+    attr_reader :name
+    def initialize(name)
+      @name = name
+    end
+  end
+  
+  class StructByReference < Type
+    def initialize(struct_class)
+      super("struct #{struct_class.to_s.gsub('::', '_')} *")
+    end
+  end
+
+  class StructByValue < Type
+    def initialize(struct_class)
+      super("struct #{struct_class.to_s.gsub('::', '_')}")
+    end
+  end
+  
+  PrimitiveTypes = {
+      :char => 'char',
+      :uchar => 'unsigned char',
+      :short => 'short',
+      :ushort => 'unsigned short',
+      :int => 'int',
+      :uint => 'unsigned int',
+      :long => 'long',
+      :ulong => 'unsigned long',
+      :float => 'float',
+      :double => 'double',
+      :pointer => 'void *',
+      :string => 'const char *',
+  }
+  
+  TypeMap = {}
+  def self.find_type(type)
+    return type if type.is_a?(Type)
+
+    t = TypeMap[type]
+    return t unless t.nil?
+
+    if PrimitiveTypes.has_key?(type)
+      return TypeMap[type] = Type.new(PrimitiveTypes[type])
+    end
+    raise TypeError.new("cannot resolve type #{type}")
+  end
+
+  class Exporter
+    attr_reader :mod, :functions
+
+    def initialize(mod)
+      @mod = mod
+      @functions = []
+      @structs = []
+    end
+
+    def attach(mname, fname, result_type, param_types)
+      @functions << { mname: mname, fname: fname, result_type: result_type, params: param_types.dup }
+    end
+    
+    def struct(name, fields)
+      @structs << { name: name, fields: fields.dup }
+    end
+    
+    def dump(out_file)
+      File.open(out_file, 'w') do |f|
+        guard = File.basename(out_file).upcase.gsub('.', '_').gsub('/', '_')
+        f.puts <<-HEADER
+#ifndef #{guard}
+#define #{guard} 1
+
+#ifndef RBFFI_EXPORT
+# ifdef __cplusplus
+#  define RBFFI_EXPORT extern "C"
+# else
+#  define RBFFI_EXPORT
+# endif
+#endif
+
+        HEADER
+        
+        @structs.each do |s|
+          f.puts "struct #{s[:name].gsub('::', '_')} {"
+          s[:fields].each do |field|
+            f.puts "#{' ' * 4}#{field[:type].name} #{field[:name].to_s};"
+          end
+          f.puts '};'
+          f.puts
+        end
+        @functions.each do |fn|
+          param_string = fn[:params].empty? ? 'void' : fn[:params].map(&:name).join(', ')
+          f.puts "RBFFI_EXPORT #{fn[:result_type].name} #{fn[:fname]}(#{param_string});"
+        end
+        f.puts <<-EPILOG
+
+#endif /* #{guard} */
+        EPILOG
+      end
+    end
+    
+  end
+
+  module Library
+    def self.extended(mod)
+      FFI.exporter = Exporter.new(mod)
+    end
+
+    def attach_function(*args)
+      FFI.exporter.attach(args[0], args[0], find_type(args[2]), args[1].map { |t| find_type(t) })
+    end
+
+    def ffi_lib(*args)
+
+    end
+
+    TypeMap = {}
+    def find_type(type)
+      t = TypeMap[type]
+      return t unless t.nil?
+      
+      if type.is_a?(Class) && type < Struct
+        return TypeMap[type] = StructByReference.new(type)
+      end
+
+      TypeMap[type] = FFI.find_type(type)
+    end
+  end
+
+  class Struct
+    def self.layout(*args)
+      fields = []
+      i = 0
+      while i < args.length
+        fields << { name: args[i], type: find_type(args[i+1]) }
+        i += 2
+      end
+      FFI.exporter.struct(self.to_s, fields)
+    end
+
+    TypeMap = {}
+    def self.find_type(type)
+      t = TypeMap[type]
+      return t unless t.nil?
+
+      if type.is_a?(Class) && type < Struct
+        return TypeMap[type] = StructByValue.new(type)
+      end
+
+      TypeMap[type] = FFI.find_type(type)
+    end
+    
+    def self.by_value
+      StructByValue.new(self)
+    end
+    
+    def self.by_ref
+      StructByReference.new(self)
+    end
+  end
+end

data/lib/ffi-compiler/loader.rb

@@ -1,14 +1,15 @@
 require 'pathname'
 require 'ffi'
+require_relative 'platform'
 
 module FFI
   module Compiler
     module Loader
       def self.find(name, start_path = nil)
-        library = FFI.map_library_name(name)
+        library = Platform.system.map_library_name(name)
         root = false
         Pathname.new(start_path || File.dirname(caller[0].split(/:/)[0])).ascend do |path|
-          Dir.glob("#{path}/**/#{library}") do |f|
+          Dir.glob("#{path}/**/{#{FFI::Platform::ARCH}-#{FFI::Platform::OS}/#{library},#{library}}") do |f|
             return f
           end
 

data/lib/ffi-compiler/platform.rb

@@ -0,0 +1,29 @@
+module FFI::Compiler
+  class Platform
+    LIBSUFFIX = FFI::Platform.mac? ? 'bundle' : FFI::Platform::LIBSUFFIX
+    
+    def self.system
+      @@system ||= Platform.new
+    end
+    
+    def map_library_name(name)
+      "#{FFI::Platform::LIBPREFIX}#{name}.#{LIBSUFFIX}"
+    end
+    
+    def arch
+      FFI::Platform::ARCH
+    end
+    
+    def os
+      FFI::Platform::OS
+    end
+    
+    def name
+      FFI::Platform.name
+    end
+    
+    def mac?
+      FFI::Platform.mac?
+    end
+  end
+end

data/lib/ffi-compiler/task.rb

@@ -1,167 +1,15 @@
+require 'rake'
 require 'rake/tasklib'
 require 'rake/clean'
 require 'ffi'
 require 'tmpdir'
 require 'rbconfig'
+require_relative 'compile_task'
 
 module FFI
-  class Compiler
-    DEFAULT_CFLAGS = %w(-fexceptions -O -fno-omit-frame-pointer -fno-strict-aliasing)
-    DEFAULT_LDFLAGS = %w(-fexceptions)
-    
-    class Task < Rake::TaskLib
-      attr_reader :cflags, :cxxflags, :ldflags, :libs
-      
-      def initialize(name)
-        @name = File.basename(name)
-        @defines = []
-        @include_paths = []
-        @library_paths = []
-        @libraries = []
-        @headers = []
-        @functions = []
-        @cflags = DEFAULT_CFLAGS.dup
-        @cxxflags = DEFAULT_CFLAGS.dup
-        @ldflags = DEFAULT_LDFLAGS.dup
-        @libs = []
-
-        yield self if block_given?
-        define_task!
-      end
-
-      def have_func?(func)
-        main = <<-C_FILE
-        extern void #{func}();
-        int main(int argc, char **argv) { #{func}(); return 0; }
-        C_FILE
-
-        if try_compile(main)
-          @functions << func
-          return true
-        end
-        false
-      end
-
-      def have_header?(header, *paths)
-        try_header(header, @include_paths) || try_header(header, paths)
-      end
-
-      def have_library?(libname, *paths)
-        try_library(libname, @library_paths) || try_library(libname, paths)
-      end
-
-      private
-      def define_task!
-        pic_flags = %w(-fPIC)
-        so_flags = []
-        
-        if FFI::Platform.mac?
-          pic_flags = []
-          so_flags << '-dynamiclib'
-
-        elsif FFI::Platform.name =~ /linux/
-          so_flags << "-shared -Wl,-soname,#{lib_name}"
-        
-        else
-          so_flags << '-shared'
-        end
-        so_flags = so_flags.join(' ')
-
-        lib_name = FFI.map_library_name(@name)
-
-        iflags = @include_paths.uniq.map { |p| "-I#{p}" }
-        defines = @functions.uniq.map { |f| "-DHAVE_#{f.upcase}=1" }
-        defines << @headers.uniq.map { |h| "-DHAVE_#{h.upcase.sub(/\./, '_')}=1" }
-
-        cflags = (@cflags + pic_flags + iflags + defines).join(' ')
-        cxxflags = (@cxxflags + @cflags + pic_flags + iflags + defines).join(' ')
-        ld_flags = (@library_paths.map { |path| "-L#{path}" } + @ldflags).join(' ')
-        libs = (@libraries.map { |l| "-l#{l}" } + @libs).join(' ')
-
-        src_files = FileList['*.{c,cpp}']
-        obj_files = src_files.ext '.o'
-        ld = src_files.detect { |f| f =~ /\.cpp$/ } ? cxx : cc
-
-        CLEAN.include(obj_files)
-
-        rule '.o' => '.c' do |t|
-          sh "#{cc} #{cflags} -o #{t.name} -c #{t.source}"
-        end
-
-        rule '.o' => '.cpp' do |t|
-          sh "#{cxx} #{cxxflags} -o #{t.name} -c #{t.source}"
-        end
-
-        desc "Build dynamic library"
-        file lib_name => obj_files do |t|
-          sh "#{ld} #{so_flags} -o #{t.name} #{t.prerequisites.join(' ')} #{ld_flags} #{libs}"
-        end
-        CLEAN.include(lib_name)
-
-        task :default => [ lib_name ]
-      end
-
-      def try_header(header, paths)
-        main = <<-C_FILE
-          #include <#{header}>
-          int main(int argc, char **argv) { return 0; }
-        C_FILE
-
-        if paths.empty? && try_compile(main)
-          @headers << header
-          return true
-        end
-
-        paths.each do |path|
-          if try_compile(main, "-I#{path}")
-            @include_paths << path
-            @headers << header
-            return true
-          end
-        end
-        false
-      end
-
-
-      def try_library(libname, paths)
-        main = <<-C_FILE
-        int main(int argc, char **argv) { return 0; }
-        C_FILE
-
-        if paths.empty? && try_compile(main)
-          @libraries << libname
-          return true
-        end
-
-        paths.each do |path|
-          if try_compile(main, "-L#{path}", "-l#{libname}")
-            @library_paths << path
-            @libraries << libname
-          end
-        end
-      end
-
-      def try_compile(src, *opts)
-        Dir.mktmpdir do |dir|
-          path = File.join(dir, 'ffi-test.c')
-          File.open(path, 'w') do |f|
-            f << src
-          end
-          begin
-            return system "#{cc} #{opts.join(' ')} -o #{File.join(dir, 'ffi-test')} #{path} >& /dev/null"
-          rescue
-            return false
-          end
-        end
-      end
-
-      def cc
-        @cc ||= (ENV['CC'] || RbConfig::CONFIG['CC'] || 'cc')
-      end
-
-      def cxx
-        @cxx ||= (ENV['CXX'] || RbConfig::CONFIG['CXX'] || 'c++')
-      end
+  module Compiler
+    class Task < CompileTask
+      warn "#{self} is deprecated"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-compiler
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2013-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -69,7 +69,13 @@ files:
 - README.md
 - Rakefile
 - LICENSE
+- lib/ffi-compiler/compile_task.rb
+- lib/ffi-compiler/export_task.rb
+- lib/ffi-compiler/exporter.rb
+- lib/ffi-compiler/fake_ffi/ffi-compiler/loader.rb
+- lib/ffi-compiler/fake_ffi/ffi.rb
 - lib/ffi-compiler/loader.rb
+- lib/ffi-compiler/platform.rb
 - lib/ffi-compiler/task.rb
 homepage: http://wiki.github.com/ffi/ffi
 licenses: