ffi-inline 0.0.3 → 0.0.4

data/examples/ex_1.rb

@@ -1,8 +1,8 @@
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../lib')))
-require 'ffi/inliner'
+require 'ffi/inline'
 
 class Foo
-  extend FFI::Inliner
+  extend FFI::Inline
 
   inline 'void say_hello (char* name) { printf("Hello, %s\n", name); }'
 end

data/ffi-inline.gemspec

@@ -1,8 +1,8 @@
-Kernel.load 'lib/ffi/inliner/version.rb'
+Kernel.load 'lib/ffi/inline/version.rb'
 
 Gem::Specification.new {|s|
   s.name         = 'ffi-inline'
-  s.version      = FFI::Inliner::Version
+  s.version      = FFI::Inline::VERSION
   s.authors      = 'meh.'
   s.email        = 'meh@paranoici.org'
   s.homepage     = 'http://github.com/meh/ruby-ffi-inline'

data/lib/ffi/inline.rb

@@ -0,0 +1,18 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'digest/sha1'
+require 'fileutils'
+require 'rbconfig'
+require 'shellwords'
+
+require 'rubygems'
+require 'ffi'
+require 'ffi/inline/inline'

data/lib/ffi/inline/builders.rb

@@ -0,0 +1,108 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI; module Inline
+
+Signature = ::Struct.new(:return, :name, :arguments, :arity, :blocking)
+
+class Builder
+	@builders = []
+
+	def self.[] (name)
+		return name if name.is_a?(Builder)
+
+		@builders.find {|builder|
+			builder.name.downcase == name.downcase ||
+			builder.aliases.any? { |ali| ali.downcase == name.downcase }
+		}
+	end
+
+	def self.define (name, *aliases, &block)
+		inherit_from = self
+
+		if name.is_a?(Builder)
+			name = name.class
+		end
+
+		if name.is_a?(Class)
+			inherit_from = name
+			name         = aliases.shift
+		end
+
+		@builders << Class.new(inherit_from, &block).tap {|k|
+			k.instance_eval {
+				define_singleton_method :name do name end
+				define_singleton_method :aliases do aliases end
+			}
+		}
+	end
+
+	attr_reader :code, :compiler
+
+	def initialize (code = '')
+		@code  = code
+		@evals = []
+	end
+
+	def use_compiler (compiler)
+		@compiler = Compiler[compiler]
+	end
+
+	def raw (code)
+		@code << code
+	end
+
+	def eval (&block)
+		@evals << block
+	end
+
+	def to_ffi_type (type)
+		raise 'the Builder has not been specialized'
+	end
+
+	def shared_object
+		raise 'the Builder has not been specialized'
+	end
+
+	def signatures
+		raise 'the Builder has not been specialized'
+	end
+
+	def symbols
+		signatures.map { |s| s.name.to_sym }
+	end
+
+	def build
+		builder = self
+		blocks  = @evals
+
+		mod = Module.new
+		mod.instance_eval {
+			extend FFI::Library
+
+			ffi_lib builder.shared_object
+
+			blocks.each { |block| instance_eval &block }
+
+			builder.signatures.each {|s|
+				attach_function s.name, s.arguments.compact.map {|a|
+					builder.to_ffi_type(a, self)
+				}, builder.to_ffi_type(s.return, self), :blocking => s.blocking
+			}
+		}
+
+		mod
+	end
+end
+
+end; end
+
+require 'ffi/inline/builders/c'
+require 'ffi/inline/builders/cpp'

data/lib/ffi/inline/builders/c.rb

@@ -0,0 +1,155 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'ffi/inline/compilers/tcc'
+require 'ffi/inline/compilers/gcc'
+
+module FFI; module Inline
+
+Builder.define :c do
+	ToFFI = {
+		'void'          => :void,
+		'char'          => :char,
+		'unsigned char' => :uchar,
+		'int'           => :int,
+		'unsigned int'  => :uint,
+		'long'          => :long,
+		'unsigned long' => :ulong,
+		'float'         => :float,
+		'double'        => :double,
+	}
+
+	attr_reader :code, :compiler, :libraries
+
+	def initialize (code = '', options = {})
+		super(code)
+
+		@types      = ToFFI.dup
+		@libraries  = options[:libraries] || []
+		@signatures = []
+
+		use_compiler options[:use_compiler] || options[:compiler] || :gcc
+
+		@signatures << parse_signature(code) if code && !code.empty?
+	end
+
+	def libraries (*libraries)
+		@libraries.concat(libraries)
+	end
+
+	def types (map = nil)
+		map ? @types.merge!(map) : @types
+	end
+	
+	alias map types
+
+	def raw (code, no_line = false)
+		return super(code) if no_line
+
+		whole, path, line = caller.find { |line| line !~ /ffi-inline/ }.match(/^(.*?):(\d+):in/).to_a
+
+		super "\n#line #{line.to_i} #{path.inspect}\n" << code
+	end
+	
+	alias c_raw raw
+
+	def include (path, options = {})
+		delimiter = (options[:quoted] || options[:local]) ? ['"', '"'] : ['<', '>']
+
+		raw "#include #{delimiter.first}#{path}#{delimiter.last}\n", true
+	end
+
+	def typedef (from, to)
+		raw "typedef #{from} #{to};"
+	end
+
+	def function (code, signature = nil)
+		parsed = parse_signature(code)
+
+		if signature
+			parsed[:arguments] = signature[:arguments] if signature[:arguments]
+			parsed[:return]    = signature[:return]    if signature[:return]
+			parsed[:blocking]  = signature[:blocking]  if signature[:blocking]
+		end
+
+		@signatures << parsed
+
+		raw code
+	end; alias c function
+
+	def struct (ffi_struct)
+		raw %{
+		typedef struct {#{
+			ffi_struct.layout.fields.map {|field|
+				"#{field} #{field.name};"
+			}.join("\n")
+		}} #{ffi_struct.class.name}
+	}, true
+	end
+
+	def to_ffi_type (type, mod = nil)
+		raise ArgumentError, 'type is nil' if type.nil?
+
+		if type.is_a?(Symbol) || type.is_a?(FFI::Type) || (type.is_a?(Class) && type.ancestors.include?(FFI::Struct))
+			type
+		elsif @types[type]
+			@types[type]
+		elsif type.to_s.include? ?*
+			:pointer
+		elsif ((mod || FFI).find_type(type.to_sym) rescue false)
+			type.to_sym
+		else
+			raise "type #{type} not supported"
+		end
+	end
+
+	def shared_object
+		@compiler.compile(@code, @libraries)
+	end
+
+	def signatures
+		@signatures
+	end
+
+private
+	def strip_comments (code)
+		code.gsub(%r(\s*/\*.*?\*/)m, '').
+			gsub(%r(^\s*//.*?\n), '').
+			gsub(%r([ \t]*//[^\n]*), '')
+	end
+
+	def parse_signature (code)
+		sig = strip_comments(code)
+
+		sig.gsub!(/^\s*\#.*(\\\n.*)*/, '') # strip preprocessor directives
+		sig.gsub!(/\s*\{.*/m, '')          # strip function body
+		sig.gsub!(/\s+/, ' ')              # clean and collapse whitespace
+		sig.gsub!(/\s*\*\s*/, ' * ')       # clean pointers
+		sig.gsub!(/\s*const\s*/, '')       # remove const
+		sig.strip!
+
+		whole, return_type, function_name, arg_string = sig.match(/(.*?(?:\ \*)?)\s*(\w+)\s*\(([^)]*)\)/).to_a
+
+		raise SyntaxError, "cannot parse signature: #{sig}" unless whole
+
+		args = arg_string.split(',').map {|arg|
+			# helps normalize into 'char * varname' form
+			arg = arg.gsub(/\s*\*\s*/, ' * ').strip
+
+			whole, type = arg.gsub(/\s*\*\s*/, ' * ').strip.match(/(((.*?(?:\ \*)?)\s*\*?)+)\s+(\w+)\s*$/).to_a
+
+			type
+		}
+
+		Signature.new(return_type, function_name, args, args.empty? ? -1 : args.length)
+	end
+end
+
+end; end

data/lib/ffi/inline/builders/cpp.rb

@@ -0,0 +1,38 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'ffi/inline/builders/c'
+require 'ffi/inline/compilers/gxx'
+
+module FFI; module Inline
+
+Builder.define Builder[:c], :cplusplus, :cxx, :cpp, 'c++' do
+	def initialize (code = '', options = {})
+		super(code, options) rescue nil
+
+		use_compiler options[:use_compiler] || options[:compiler] || :gxx
+	end
+
+	def function (code, signature = nil)
+		parsed = parse_signature(code)
+
+		if signature
+			parsed[:arguments] = signature[:arguments] if signature[:arguments]
+			parsed[:return]    = signature[:return]    if signature[:return]
+			parsed[:blocking]  = signature[:blocking]  if signature[:blocking]
+		end
+
+		@signatures << parsed
+
+		raw %{extern "C" {#{code} }\n}
+	end
+end
+
+end; end

data/lib/ffi/inline/compilers.rb

@@ -0,0 +1,63 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI; module Inline
+
+class Compiler
+	Extension = case RbConfig::CONFIG['target_os']
+		when /darwin/      then 'dylib'
+		when /mswin|mingw/ then 'dll'
+		else                    'so'
+		end
+
+	@compilers = []
+
+	def self.[] (name)
+		return name if name.is_a?(Compiler)
+
+		@compilers.find {|compiler|
+			compiler.name.downcase == name.downcase ||
+			compiler.aliases.any? { |ali| ali.downcase == name.downcase }
+		}
+	end
+
+	def self.define (name, *aliases, &block)
+		inherit_from = self
+
+		if name.is_a?(Compiler)
+			name = name.class
+		end
+
+		if name.is_a?(Class)
+			inherit_from = name
+			name         = aliases.shift
+		end
+
+		@compilers << Class.new(inherit_from, &block).new(name, *aliases)
+	end
+
+	attr_reader   :name, :aliases
+	attr_accessor :options
+
+	def initialize (name, *aliases)
+		@name    = name
+		@aliases = aliases
+	end
+
+	def exists?
+		raise 'the Compiler has not been specialized'
+	end
+
+	def compile
+		raise 'the Compiler has not been specialized'
+	end
+end
+
+end; end

data/lib/ffi/inline/compilers/gcc.rb

@@ -0,0 +1,67 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI; module Inline
+
+Compiler.define :gcc do
+	def exists?
+		`gcc -v 2>&1'`; $?.success?
+	end
+
+	def compile (code, libraries = [])
+		@code      = code
+		@libraries = libraries
+
+		return output if File.exists?(output)
+
+		unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+				"sh -c '#{ldshared} #{ENV['CFLAGS']} -o #{output.shellescape} #{input.shellescape} #{libs}' 2>#{log.shellescape}"
+		else
+			"#{ldshared} #{ENV['CFLAGS']} -o #{output.shellescape} #{input.shellescape} #{libs} 2>#{log.shellescape}"
+		end)
+			raise CompilationError.new(log)
+		end
+
+		output
+	end
+
+private
+	def digest
+		Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
+	end
+
+	def input
+		File.join(Inline.directory, "#{digest}.c").tap {|path|
+			File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+		}
+	end
+
+	def output
+		File.join(Inline.directory, "#{digest}.#{Compiler::Extension}")
+	end
+
+	def log
+		File.join(Inline.directory, "#{digest}.log")
+	end
+
+	def ldshared
+		if RbConfig::CONFIG['target_os'] =~ /darwin/
+			"gcc -dynamic -bundle -fPIC #{options} #{ENV['LDFLAGS']}"
+		else
+			"gcc -shared -fPIC #{options} #{ENV['LDFLAGS']}"
+		end
+	end
+
+	def libs
+		@libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
+	end
+end
+
+end; end

data/lib/ffi/inline/compilers/gxx.rb

@@ -0,0 +1,33 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI; module Inline
+
+Compiler.define Compiler[:gcc], :gxx, 'g++' do
+	def exists?
+		`g++ -v 2>&1'`; $?.success?
+	end
+
+	def input
+		File.join(Inline.directory, "#{digest}.cpp").tap {|path|
+			File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+		}
+	end
+
+	def ldshared
+		if RbConfig::CONFIG['target_os'] =~ /darwin/
+			"g++ -dynamic -bundle -fPIC #{options} #{ENV['LDFLAGS']}"
+		else
+			"g++ -shared -fPIC #{options} #{ENV['LDFLAGS']}"
+		end
+	end
+end
+
+end; end

data/lib/ffi/inline/compilers/tcc.rb

@@ -0,0 +1,67 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI; module Inline
+
+Compiler.define :tcc do
+	def exists?
+		`tcc -v 2>&1'`; $?.success?
+	end
+
+	def compile (code, libraries = [])
+		@code      = code
+		@libraries = libraries
+
+		return output if File.exists?(output)
+
+		unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+			"sh -c '#{ldshared} #{ENV['CFLAGS']} #{libs} -o #{output.shellescape} #{input.shellescape}' 2>#{log.shellescape}"
+		else
+			"#{ldshared} #{ENV['CFLAGS']} #{libs} -o #{output.shellescape} #{input.shellescape} 2>#{log.shellescape}"
+		end)
+			raise CompilationError.new(log)
+		end
+
+		output
+	end
+
+private
+	def digest
+		Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
+	end
+
+	def input
+		File.join(Inline.directory, "#{digest}.c").tap {|path|
+			File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+		}
+	end
+
+	def output
+		File.join(Inline.directory, "#{digest}.#{Compiler::Extension}")
+	end
+
+	def log
+		File.join(Inline.directory, "#{digest}.log")
+	end
+
+	def ldshared
+		if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+			"tcc -rdynamic -shared -fPIC #{options} #{ENV['LDFLAGS']}"
+		else
+			"tcc -shared #{options} #{ENV['LDFLAGS']}"
+		end
+	end
+
+	def libs
+		@libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
+	end
+end
+
+end; end

data/lib/ffi/inline/error.rb

@@ -0,0 +1,21 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+class CompilationError < RuntimeError
+	def initialize (path)
+		@path = path
+
+		super "compile error: see logs at #{@path}"
+	end
+
+	def log
+		File.read(@path)
+	end
+end

data/lib/ffi/inline/inline.rb

@@ -0,0 +1,83 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'ffi/inline/error'
+
+module FFI
+
+module Inline
+	def self.directory
+		if ENV['FFI_INLINER_PATH'] && !ENV['FFI_INLINER_PATH'].empty?
+			@directory = ENV['FFI_INLINER_PATH']
+		else
+			require 'tmpdir'
+			@directory ||= File.expand_path(File.join(Dir.tmpdir, ".ffi-inline-#{Process.uid}"))
+		end
+
+		if File.exists?(@directory) && !File.directory?(@directory)
+			raise 'the FFI_INLINER_PATH exists and is not a directory'
+		end
+
+		if !File.exists?(@directory)
+			FileUtils.mkdir(@directory)
+		end
+
+		@directory
+	end
+
+	def inline (*args, &block)
+		if self.class == Class
+			instance_inline(*args, &block)
+		else
+			singleton_inline(*args, &block)
+		end
+	end
+
+	def singleton_inline (*args)
+		options = args.last.is_a?(Hash) ? args.pop : {}
+
+		language, code = if args.length == 2
+			args
+		else
+			block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
+		end
+
+		builder = Builder[language].new(code, options)
+		yield builder if block_given?
+		mod = builder.build
+
+		builder.symbols.each {|sym|
+			define_singleton_method sym, &mod.method(sym)
+		}
+	end
+
+	def instance_inline (*args)
+		options = args.last.is_a?(Hash) ? args.pop : {}
+
+		language, code = if args.length == 2
+			args
+		else
+			block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
+		end
+
+		builder = Builder[language].new(code, options)
+		yield builder if block_given?
+		mod = builder.build
+
+		builder.symbols.each {|sym|
+			define_method sym, &mod.method(sym)
+		}
+	end
+end
+
+end
+
+require 'ffi/inline/compilers'
+require 'ffi/inline/builders'

data/lib/ffi/inline/version.rb

@@ -0,0 +1,17 @@
+#--
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                  Version 2, December 2004
+#
+#          DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+#
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module FFI
+
+module Inline
+  VERSION = '0.0.4'
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-inline
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-22 00:00:00.000000000 Z
+date: 2012-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -68,17 +68,17 @@ files:
 - Rakefile
 - examples/ex_1.rb
 - ffi-inline.gemspec
-- lib/ffi/inliner.rb
-- lib/ffi/inliner/builders.rb
-- lib/ffi/inliner/builders/c.rb
-- lib/ffi/inliner/builders/cpp.rb
-- lib/ffi/inliner/compilers.rb
-- lib/ffi/inliner/compilers/gcc.rb
-- lib/ffi/inliner/compilers/gxx.rb
-- lib/ffi/inliner/compilers/tcc.rb
-- lib/ffi/inliner/error.rb
-- lib/ffi/inliner/inliner.rb
-- lib/ffi/inliner/version.rb
+- lib/ffi/inline.rb
+- lib/ffi/inline/builders.rb
+- lib/ffi/inline/builders/c.rb
+- lib/ffi/inline/builders/cpp.rb
+- lib/ffi/inline/compilers.rb
+- lib/ffi/inline/compilers/gcc.rb
+- lib/ffi/inline/compilers/gxx.rb
+- lib/ffi/inline/compilers/tcc.rb
+- lib/ffi/inline/error.rb
+- lib/ffi/inline/inline.rb
+- lib/ffi/inline/version.rb
 - spec/inliner_spec.rb
 homepage: http://github.com/meh/ruby-ffi-inline
 licenses: []

data/lib/ffi/inliner.rb

@@ -1,8 +0,0 @@
-require 'digest/sha1'
-require 'fileutils'
-require 'rbconfig'
-require 'shellwords'
-
-require 'rubygems'
-require 'ffi'
-require 'ffi/inliner/inliner'

data/lib/ffi/inliner/builders.rb

@@ -1,98 +0,0 @@
-module FFI; module Inliner
-
-Signature = ::Struct.new(:return, :name, :arguments, :arity, :blocking)
-
-class Builder
-  @builders = []
-
-  def self.[](name)
-    return name if name.is_a?(Builder)
-
-    @builders.find {|builder|
-      builder.name.downcase == name.downcase ||
-      builder.aliases.any? { |ali| ali.downcase == name.downcase }
-    }
-  end
-
-  def self.define (name, *aliases, &block)
-    inherit_from = self
-
-    if name.is_a?(Builder)
-      name = name.class
-    end
-
-    if name.is_a?(Class)
-      inherit_from = name
-      name         = aliases.shift
-    end
-
-    @builders << Class.new(inherit_from, &block).tap {|k|
-      k.instance_eval {
-        define_singleton_method :name do name end
-        define_singleton_method :aliases do aliases end
-      }
-    }
-  end
-
-  attr_reader :code, :compiler
-
-  def initialize(code = "")
-    @code  = code
-    @evals = []
-  end
-
-  def use_compiler(compiler)
-    @compiler = Compiler[compiler]
-  end
-
-  def raw(code)
-    @code << code
-  end
-
-  def eval(&block)
-    @evals << block
-  end
-
-  def to_ffi_type(type)
-    raise 'the Builder has not been specialized'
-  end
-
-  def shared_object
-    raise 'the Builder has not been specialized'
-  end
-
-  def signatures
-    raise 'the Builder has not been specialized'
-  end
-
-  def symbols
-    signatures.map { |s| s.name.to_sym }
-  end
-
-  def build
-    builder = self
-    blocks  = @evals
-
-    mod = Module.new
-    mod.instance_eval {
-      extend FFI::Library
-
-      ffi_lib builder.shared_object
-
-      blocks.each { |block| instance_eval &block }
-
-      builder.signatures.each {|s|
-        attach_function s.name, s.arguments.compact.map {|a|
-          builder.to_ffi_type(a, self)
-        }, builder.to_ffi_type(s.return, self), :blocking => s.blocking
-      }
-    }
-
-    mod
-  end
-end
-
-end; end
-
-require 'ffi/inliner/builders/c'
-require 'ffi/inliner/builders/cpp'

data/lib/ffi/inliner/builders/c.rb

@@ -1,147 +0,0 @@
-require 'ffi/inliner/compilers/tcc'
-require 'ffi/inliner/compilers/gcc'
-
-module FFI; module Inliner
-
-Builder.define :c do
-  ToFFI = {
-    'void'          => :void,
-    'char'          => :char,
-    'unsigned char' => :uchar,
-    'int'           => :int,
-    'unsigned int'  => :uint,
-    'long'          => :long,
-    'unsigned long' => :ulong,
-    'float'         => :float,
-    'double'        => :double,
-  }
-
-  attr_reader :code, :compiler, :libraries
-
-  def initialize(code = nil, options = {})
-    super(code)
-
-    @types     = ToFFI.dup
-    @libraries = options[:libraries] || []
-
-    @signatures = []
-
-    use_compiler options[:use_compiler] || options[:compiler] || :gcc
-
-    @signatures << parse_signature(code) if code && !code.empty?
-  end
-
-  def libraries(*libraries)
-    @libraries.concat(libraries)
-  end
-
-  def types(map = nil)
-    map ? @types.merge!(map) : @types
-  end; alias map types
-
-  def raw(code, no_line = false)
-    return super(code) if no_line
-
-    whole, path, line = caller.find { |line| line !~ /ffi-inliner/ }.match(/^(.*?):(\d+):in/).to_a
-
-    super "\n#line #{line.to_i} #{path.inspect}\n" << code
-  end; alias c_raw raw
-
-  def include(path, options = {})
-    delimiter = (options[:quoted] || options[:local]) ? ['"', '"'] : ['<', '>']
-
-    raw "#include #{delimiter.first}#{path}#{delimiter.last}\n", true
-  end
-
-  def typedef (from, to)
-    raw "typedef #{from} #{to};"
-  end
-
-  def function(code, signature = nil)
-    parsed = parse_signature(code)
-
-    if signature
-      parsed[:arguments] = signature[:arguments] if signature[:arguments]
-      parsed[:return]    = signature[:return]    if signature[:return]
-      parsed[:blocking]  = signature[:blocking]  if signature[:blocking]
-    end
-
-    @signatures << parsed
-
-    raw code
-  end; alias c function
-
-  def struct(ffi_struct)
-    raw %{
-      typedef struct {#{
-        ffi_struct.layout.fields.map {|field|
-          "#{field} #{field.name};"
-        }.join("\n")
-      }} #{ffi_struct.class.name}
-    }, true
-  end
-
-  def to_ffi_type(type, mod = nil)
-    raise ArgumentError, 'type is nil' if type.nil?
-
-    if type.is_a?(Symbol) || type.is_a?(FFI::Type) || (type.is_a?(Class) && type.ancestors.include?(FFI::Struct))
-      type
-    elsif @types[type]
-      @types[type]
-    elsif type.to_s.include? ?*
-      :pointer
-    elsif ((mod || FFI).find_type(type.to_sym) rescue false)
-      type.to_sym
-    else
-      raise "type #{type} not supported"
-    end
-  end
-
-  def shared_object
-    @compiler.compile(@code, @libraries)
-  end
-
-  def signatures
-    @signatures
-  end
-
-private
-
-  # Based on RubyInline code by Ryan Davis
-  # Copyright (c) 2001-2007 Ryan Davis, Zen Spider Software
-  def strip_comments(code)
-    code.gsub(%r(\s*/\*.*?\*/)m, '').
-         gsub(%r(^\s*//.*?\n), '').
-         gsub(%r([ \t]*//[^\n]*), '')
-  end
-
-  # Based on RubyInline code by Ryan Davis
-  # Copyright (c) 2001-2007 Ryan Davis, Zen Spider Software
-  def parse_signature(code)
-    sig = strip_comments(code)
-
-    sig.gsub!(/^\s*\#.*(\\\n.*)*/, '') # strip preprocessor directives
-    sig.gsub!(/\s*\{.*/m, '')          # strip function body
-    sig.gsub!(/\s+/, ' ')              # clean and collapse whitespace
-    sig.gsub!(/\s*\*\s*/, ' * ')       # clean pointers
-    sig.gsub!(/\s*const\s*/, '')       # remove const
-    sig.strip!
-
-    whole, return_type, function_name, arg_string = sig.match(/(.*?(?:\ \*)?)\s*(\w+)\s*\(([^)]*)\)/).to_a
-
-    raise SyntaxError, "cannot parse signature: #{sig}" unless whole
-
-    args = arg_string.split(',').map {|arg|
-      # helps normalize into 'char * varname' form
-      arg = arg.gsub(/\s*\*\s*/, ' * ').strip
-
-      whole, type = arg.gsub(/\s*\*\s*/, ' * ').strip.match(/(((.*?(?:\ \*)?)\s*\*?)+)\s+(\w+)\s*$/).to_a
-
-      type
-    }
-
-    Signature.new(return_type, function_name, args, args.empty? ? -1 : args.length)
-  end
-end
-
-end; end

data/lib/ffi/inliner/builders/cpp.rb

@@ -1,28 +0,0 @@
-require 'ffi/inliner/builders/c'
-require 'ffi/inliner/compilers/gxx'
-
-module FFI; module Inliner
-
-Builder.define Builder[:c], :cplusplus, :cxx, :cpp, 'c++' do
-  def initialize(code = "", options = {})
-    super(code, options) rescue nil
-
-    use_compiler options[:use_compiler] || options[:compiler] || :gxx
-  end
-
-  def function(code, signature = nil)
-    parsed = parse_signature(code)
-
-    if signature
-      parsed[:arguments] = signature[:arguments] if signature[:arguments]
-      parsed[:return]    = signature[:return]    if signature[:return]
-      parsed[:blocking]  = signature[:blocking]  if signature[:blocking]
-    end
-
-    @signatures << parsed
-
-    raw 'extern "C" {' << code << '}' << "\n"
-  end
-end
-
-end; end

data/lib/ffi/inliner/compilers.rb

@@ -1,53 +0,0 @@
-module FFI; module Inliner
-
-class Compiler
-  Extension = case RbConfig::CONFIG['target_os']
-    when /darwin/      then 'dylib'
-    when /mswin|mingw/ then 'dll'
-    else                    'so'
-    end
-
-  @compilers = []
-
-  def self.[] (name)
-    return name if name.is_a?(Compiler)
-
-    @compilers.find {|compiler|
-      compiler.name.downcase == name.downcase ||
-      compiler.aliases.any? { |ali| ali.downcase == name.downcase }
-    }
-  end
-
-  def self.define (name, *aliases, &block)
-    inherit_from = self
-
-    if name.is_a?(Compiler)
-      name = name.class
-    end
-
-    if name.is_a?(Class)
-      inherit_from = name
-      name         = aliases.shift
-    end
-
-    @compilers << Class.new(inherit_from, &block).new(name, *aliases)
-  end
-
-  attr_reader   :name, :aliases
-  attr_accessor :options
-
-  def initialize(name, *aliases)
-    @name    = name
-    @aliases = aliases
-  end
-
-  def exists?
-    raise 'the Compiler has not been specialized'
-  end
-
-  def compile
-    raise 'the Compiler has not been specialized'
-  end
-end
-
-end; end

data/lib/ffi/inliner/compilers/gcc.rb

@@ -1,57 +0,0 @@
-module FFI; module Inliner
-
-Compiler.define :gcc do
-  def exists?
-    `gcc -v 2>&1'`; $?.success?
-  end
-
-  def compile (code, libraries = [])
-    @code      = code
-    @libraries = libraries
-
-    return output if File.exists?(output)
-
-    unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
-      "sh -c '#{ldshared} #{ENV['CFLAGS']} -o #{output.shellescape} #{input.shellescape} #{libs}' 2>#{log.shellescape}"
-    else
-      "#{ldshared} #{ENV['CFLAGS']} -o #{output.shellescape} #{input.shellescape} #{libs} 2>#{log.shellescape}"
-    end)
-      raise CompilationError.new(log)
-    end
-
-    output
-  end
-
-  private
-  def digest
-    Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
-  end
-
-  def input
-    File.join(Inliner.directory, "#{digest}.c").tap {|path|
-      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
-    }
-  end
-
-  def output
-    File.join(Inliner.directory, "#{digest}.#{Compiler::Extension}")
-  end
-
-  def log
-    File.join(Inliner.directory, "#{digest}.log")
-  end
-
-  def ldshared
-    if RbConfig::CONFIG['target_os'] =~ /darwin/
-      "gcc -dynamic -bundle -fPIC #{options} #{ENV['LDFLAGS']}"
-    else
-      "gcc -shared -fPIC #{options} #{ENV['LDFLAGS']}"
-    end
-  end
-
-  def libs
-    @libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
-  end
-end
-
-end; end

data/lib/ffi/inliner/compilers/gxx.rb

@@ -1,23 +0,0 @@
-module FFI; module Inliner
-
-Compiler.define Compiler[:gcc], :gxx, 'g++' do
-  def exists?
-    `g++ -v 2>&1'`; $?.success?
-  end
-
-  def input
-    File.join(Inliner.directory, "#{digest}.cpp").tap {|path|
-      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
-    }
-  end
-
-  def ldshared
-    if RbConfig::CONFIG['target_os'] =~ /darwin/
-      "g++ -dynamic -bundle -fPIC #{options} #{ENV['LDFLAGS']}"
-    else
-      "g++ -shared -fPIC #{options} #{ENV['LDFLAGS']}"
-    end
-  end
-end
-
-end; end

data/lib/ffi/inliner/compilers/tcc.rb

@@ -1,57 +0,0 @@
-module FFI; module Inliner
-
-Compiler.define :tcc do
-  def exists?
-    `tcc -v 2>&1'`; $?.success?
-  end
-
-  def compile (code, libraries = [])
-    @code      = code
-    @libraries = libraries
-
-    return output if File.exists?(output)
-
-    unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
-      "sh -c '#{ldshared} #{ENV['CFLAGS']} #{libs} -o #{output.shellescape} #{input.shellescape}' 2>#{log.shellescape}"
-    else
-      "#{ldshared} #{ENV['CFLAGS']} #{libs} -o #{output.shellescape} #{input.shellescape} 2>#{log.shellescape}"
-    end)
-      raise CompilationError.new(log)
-    end
-
-    output
-  end
-
-  private
-  def digest
-    Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
-  end
-
-  def input
-    File.join(Inliner.directory, "#{digest}.c").tap {|path|
-      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
-    }
-  end
-
-  def output
-    File.join(Inliner.directory, "#{digest}.#{Compiler::Extension}")
-  end
-
-  def log
-    File.join(Inliner.directory, "#{digest}.log")
-  end
-
-  def ldshared
-    if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
-      "tcc -rdynamic -shared -fPIC #{options} #{ENV['LDFLAGS']}"
-    else
-      "tcc -shared #{options} #{ENV['LDFLAGS']}"
-    end
-  end
-
-  def libs
-    @libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
-  end
-end
-
-end; end

data/lib/ffi/inliner/error.rb

@@ -1,11 +0,0 @@
-class CompilationError < RuntimeError
-  def initialize (path)
-    @path = path
-
-    super "compile error: see logs at #{@path}"
-  end
-
-  def log
-    File.read(@path)
-  end
-end

data/lib/ffi/inliner/inliner.rb

@@ -1,73 +0,0 @@
-require 'ffi/inliner/error'
-
-module FFI
-
-module Inliner
-  def self.directory
-    if ENV['FFI_INLINER_PATH'] && !ENV['FFI_INLINER_PATH'].empty?
-      @directory = ENV['FFI_INLINER_PATH']
-    else
-      require 'tmpdir'
-      @directory ||= File.expand_path(File.join(Dir.tmpdir, ".ffi-inliner-#{Process.uid}"))
-    end
-
-    if File.exists?(@directory) && !File.directory?(@directory)
-      raise 'the FFI_INLINER_PATH exists and is not a directory'
-    end
-
-    if !File.exists?(@directory)
-      FileUtils.mkdir(@directory)
-    end
-
-    @directory
-  end
-
-  def inline(*args, &block)
-    if self.class == Class
-      instance_inline(*args, &block)
-    else
-      singleton_inline(*args, &block)
-    end
-  end
-
-  def singleton_inline(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-
-    language, code = if args.length == 2
-      args
-    else
-      block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
-    end
-
-    builder = Builder[language].new(code, options)
-    yield builder if block_given?
-    mod = builder.build
-
-    builder.symbols.each {|sym|
-      define_singleton_method sym, &mod.method(sym)
-    }
-  end
-
-  def instance_inline(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-
-    language, code = if args.length == 2
-      args
-    else
-      block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
-    end
-
-    builder = Builder[language].new(code, options)
-    yield builder if block_given?
-    mod = builder.build
-
-    builder.symbols.each {|sym|
-      define_method sym, &mod.method(sym)
-    }
-  end
-end
-
-end
-
-require 'ffi/inliner/compilers'
-require 'ffi/inliner/builders'

data/lib/ffi/inliner/version.rb

@@ -1,7 +0,0 @@
-module FFI
-
-module Inliner
-  Version = '0.0.3'
-end
-
-end