rdp-ffi-inliner 0.2.4.1

data/.gitignore

@@ -0,0 +1,7 @@
+*~
+*.*~
+^#
+pkg
+announcement.txt
+cache
+

data/History.txt

@@ -0,0 +1,47 @@
+== 0.2.4 / 2010-06-09
+
+* Bug fix
+  * Fix Issue #3: Added missing 'require' for FileUtils
+  * Fix Issue #5: instance variable @libraries not initialized warning
+
+== 0.2.3 / 2009-12-07
+
+* Minor enhancements
+  * Add Builder#include method to include library and user header files
+  * Add Builder#library method to link with custom libraries
+  * Add experimental support for wrapping C++ through C. When using 
+    GPlusPlus compiler, the inliner will automatically wraps C code 
+    inside an extern "C" block.
+* Bug fix
+  * Fix Issue#2: TCC generated shared libraries do not work in Windows 
+    (thanks to Luis Lavena)
+* Changes in the API
+  * Rename #compiler in #use_compiler
+  * Now #compiler returns the current compiler
+
+== 0.2.2 / 2009-08-05
+
+* Bug fix
+  * Fix ffi gem version dependency issue
+
+== 0.2.1 / 2009-08-05
+
+* Bug fix
+  * Add fPIC option to gcc compiler to fix AMD64 compilation issue
+
+== 0.2.0 / 2009-07-20
+
+* Major enhancements
+  * Add support for different compiler backends
+  * Improve compatibility with Windows and OSX boxes
+* Minor enhancements
+  * Add support for configuration block syntax
+  * Remove dependency from ffi-tcc and libtcc
+  * Improve compatibility with MRI 1.9.1
+  * Cleanup and code refactoring
+
+== 0.1.0 / 2009-07-07
+
+* 1 major enhancement
+  * Birthday!
+

data/README.rdoc

@@ -0,0 +1,87 @@
+ffi-inliner
+  by Andrea Fazzi
+  http://github.com/remogatto/ffi-inliner
+
+== DESCRIPTION:
+
+With ffi-inliner you can run C code within your ruby script.
+
+== FEATURES/PROBLEMS:
+
+* Mix C snippets in your Ruby code and gulp it on the fly!
+* It's based on Ruby-FFI so the C code you inject is portable across
+  Ruby implementations!
+* Yep, it means that you can run it on JRuby too!
+* Fast compilation through tcc[http://bellard.org/tcc/]
+* But it can use the system's compiler (e.g. gcc) on those platforms
+  that don't support tcc (e.g. OSX) or that don't have it installed
+
+== SYNOPSIS:
+
+  require 'ffi-inliner'
+
+  module MyLib
+    extend Inliner
+    inline 'void say_hello(char* name) { printf("Hello, %s\n", name); }'
+  end
+
+  MyLib.say_hello('boys')
+
+  class Foo
+    include MyLib
+  end
+
+  Foo.new.say_hello('foos')
+
+For other hints see the examples/ folder or visit the
+wiki[http://wiki.github.com/remogatto/ffi-inliner/tutorial]. For a
+"real" world example you may be interested to
+ffi-life[http://github.com/remogatto/ffi-life].
+
+== REQUIREMENTS:
+
+* ffi >= 0.4.0
+* gcc and/or tcc >= 0.9.25 (optional)
+
+== DOWNLOAD/INSTALL:
+
+From rubyforge:
+
+  [sudo] gem install ffi-inliner
+
+or from github:
+
+  git clone git://github.com/remogatto/ffi-inliner
+  cd ffi-inliner
+  sudo rake gem:install
+
+== CREDITS
+
+This software is inspired to
+RubyInline[http://www.zenspider.com/ZSS/Products/RubyInline/] by Ryan
+Davis. Thank you Ryan.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Andrea Fazzi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,44 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+require 'ffi-inliner/version'
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+CLOBBER << '*~' << '*.*~'
+
+PROJ.name = 'rdp-ffi-inliner'
+PROJ.authors = 'Andrea Fazzi'
+PROJ.email = 'andrea.fazzi@alcacoop.it'
+PROJ.url = 'http://github.com/remogatto/ffi-inliner'
+PROJ.version = Inliner::VERSION
+
+PROJ.readme_file = 'README.rdoc'
+
+PROJ.rubyforge.name = 'ffi-inliner'
+
+PROJ.ann.paragraphs << 'FEATURES' << 'SYNOPSIS' << 'REQUIREMENTS' << 'DOWNLOAD/INSTALL' << 'CREDITS'
+PROJ.ann.email[:from] = 'andrea.fazzi@alcacoop.it'
+PROJ.ann.email[:to] << 'ruby-ffi@googlegroups.com'
+PROJ.ann.email[:server] = 'smtp.gmail.com'
+
+PROJ.spec.opts << '--color' << '-fs'
+
+PROJ.ruby_opts = []
+
+depend_on 'ffi', '>=0.4.0'
+
+task :default => 'spec'
+
+# EOF

data/examples/ex_1.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../lib')))
+require 'ffi-inliner'
+
+module MyLib
+  extend Inliner
+  inline 'void say_hello(char* name) { printf("Hello, %s\n", name); }'
+end
+
+MyLib.say_hello('boys')
+
+class Foo
+  include MyLib
+end
+
+Foo.new.say_hello('foos')
+
+
+
+
+
+
+
+

data/lib/ffi-inliner.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'digest/md5'
+require 'fileutils'
+require 'rbconfig'
+require 'ffi'
+require 'ffi-inliner/inliner'

data/lib/ffi-inliner/inliner.rb

@@ -0,0 +1,308 @@
+module Inliner
+
+  DEV_NULL = if Config::CONFIG['target_os'] =~ /mswin|mingw/
+               'nul'
+             else
+               '/dev/null'
+             end
+
+  LIB_EXT = if Config::CONFIG['target_os'] =~ /darwin/
+              '.dylib'
+            elsif Config::CONFIG['target_os'] =~ /mswin|mingw/
+              '.dll'
+            else
+              '.so'
+            end
+
+  C_TO_FFI = {
+    'void' => :void,
+    'char' => :char,
+    'unsigned char' => :uchar,
+    'int' => :int,
+    'unsigned int' => :uint,
+    'long' => :long,
+    'unsigned long' => :ulong,
+    'float' => :float,
+    'double' => :double,
+  }
+
+  @@__inliner_directory = File.expand_path(File.join('~/', '.ffi-inliner'))
+
+  class << self
+    def directory
+      @@__inliner_directory
+    end
+  end
+
+  class FilenameManager
+    def initialize(mod, code, libraries)
+      @mod = mod.name.gsub(/[:#<>\/]/, '_')
+      @code = code
+      @libraries = libraries
+    end
+    def cached?
+      exists?
+    end
+    def exists?
+      File.exists?(c_fn)
+    end
+    def base_fn
+      File.join(Inliner.directory, "#{@mod}_#{(Digest::MD5.new << @code << @libraries.to_s).to_s[0, 4]}")      
+    end
+    %w(c rb log).each do |ext|
+      define_method("#{ext}_fn") { "#{base_fn}.#{ext}" }
+    end
+    def so_fn
+      "#{base_fn}#{LIB_EXT}"
+    end
+  end
+
+  module Compilers
+    class Compiler
+      attr_reader :progname
+      def self.check_and_create(fm = nil, libraries = nil)
+        compiler = new(fm, libraries) 
+        unless compiler.exists?
+          raise "Can't find compiler #{compiler.class}"
+        else
+          compiler
+        end
+      end
+      def initialize(fm = nil, libraries = nil)
+        @fm = fm
+        @libraries = libraries
+        @progname = cmd.split.first
+      end
+      def compile
+        puts 'running:' + cmd if $VERBOSE
+        raise "Compile error! See #{@fm.log_fn}" unless system(cmd)
+      end
+      private
+      def libs
+        @libraries.inject("") { |str, lib| str << "-l#{lib} " } if @libraries
+      end
+    end
+
+    class GCC < Compiler
+      def exists?
+        IO.popen("#{@progname} 2>&1") { |f| f.gets } ? true : false
+      end
+      def ldshared
+        if Config::CONFIG['target_os'] =~ /darwin/
+          'gcc -dynamic -bundle -fPIC'
+        else
+          'gcc -shared -fPIC'
+        end
+      end
+      def cmd
+        "#{ldshared} #{libs} -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\" 2>\"#{@fm.log_fn}\""
+      end
+    end
+
+    class GPlusPlus < GCC
+      def ldshared
+        if Config::CONFIG['target_os'] =~ /darwin/
+          'g++ -dynamic -bundle -fPIC'
+        elsif ENV['OS'] == 'Windows_NT'
+          # windows requires use of sh first
+          def cmd
+            "sh -c 'g++ -shared -fPIC #{libs} -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\"' 2>\"#{@fm.log_fn}\""
+          end        
+        else
+          # Linux
+          'g++ -shared -fPIC'
+        end
+      end
+    end
+
+    class TCC < Compiler
+      def exists?
+        IO.popen("#{@progname}") { |f| f.gets } ? true : false
+      end
+      def cmd
+        if Config::CONFIG['target_os'] =~ /mswin|mingw/
+          "tcc -rdynamic -shared #{libs} -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\" 2>\"#{@fm.log_fn}\""
+        else
+          "tcc -shared #{libs} -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\" 2>\"#{@fm.log_fn}\""
+        end
+      end
+    end
+  end
+
+  class Builder
+    attr_reader :code, :compiler
+    def initialize(mod, code = "", options = {})
+      make_pointer_types
+      @mod = mod
+      @code = code
+      @sig = [parse_signature(@code)] unless @code.empty?
+      options = { :use_compiler => Compilers::GCC }.merge(options)
+      @compiler = options[:use_compiler]
+      @libraries = []
+    end
+
+    def map(type_map)
+      @types.merge!(type_map)
+    end
+    
+    def include(fn, options = {})
+      options[:quoted] ? @code << "#include \"#{fn}\"\n" : @code << "#include <#{fn}>\n"
+    end
+
+    def library(*libraries)
+      (@libraries ||= []).concat(libraries)
+    end
+
+    def c(code)
+      (@sig ||= []) << parse_signature(code)
+      @code << (@compiler == Compilers::GPlusPlus ? "extern \"C\" {\n#{code}\n}" : code )
+    end
+
+    def c_raw(code)
+      @code << code
+    end
+
+    def use_compiler(compiler)
+      @compiler = compiler
+    end
+
+    def struct(ffi_struct)
+      @code << "typedef struct {"
+      ffi_struct.layout.fields.each do |field|
+        @code << "#{field} #{field.name};\n"
+      end
+      @code << "} #{ffi_struct.class.name}"
+    end
+
+    def build
+      @fm = FilenameManager.new(@mod, @code, @libraries)
+      @compiler = @compiler.check_and_create(@fm, @libraries)
+      unless @fm.cached?
+        write_files(@code, @sig)
+        @compiler.compile
+        @mod.instance_eval generate_ffi(@sig)
+      else
+        @mod.instance_eval(File.read(@fm.rb_fn))
+      end
+    end
+    
+    private
+
+    def make_pointer_types
+      @types = C_TO_FFI.dup
+      C_TO_FFI.each_key do |k|
+        @types["#{k} *"] = :pointer
+      end    
+    end
+
+    def cached?(name, code)
+      File.exists?(cname(name, code))
+    end
+
+    def to_ffi_type(c_type)
+      @types[c_type]
+    end
+
+    # Based on RubyInline code by Ryan Davis
+    # Copyright (c) 2001-2007 Ryan Davis, Zen Spider Software
+    def strip_comments(code)
+      # strip c-comments
+      src = code.gsub(%r%\s*/\*.*?\*/%m, '')
+      # strip cpp-comments
+      src = src.gsub(%r%^\s*//.*?\n%, '')
+      src = src.gsub(%r%[ \t]*//[^\n]*%, '')
+      src
+    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)
+
+      # strip preprocessor directives
+      sig.gsub!(/^\s*\#.*(\\\n.*)*/, '')
+      # strip {}s
+      sig.gsub!(/\{[^\}]*\}/, '{ }')
+      # clean and collapse whitespace
+      sig.gsub!(/\s+/, ' ')
+
+      # types = 'void|int|char|char\s\*|void\s\*'
+      types = @types.keys.map{|x| Regexp.escape(x)}.join('|')
+      sig = sig.gsub(/\s*\*\s*/, ' * ').strip
+
+      if /(#{types})\s*(\w+)\s*\(([^)]*)\)/ =~ sig then
+        return_type, function_name, arg_string = $1, $2, $3
+        args = []
+        arg_string.split(',').each do |arg|
+
+          # helps normalize into 'char * varname' form
+          arg = arg.gsub(/\s*\*\s*/, ' * ').strip
+
+          if /(((#{types})\s*\*?)+)\s+(\w+)\s*$/ =~ arg then
+            args.push($1)
+          elsif arg != "void" then
+            warn "WAR\NING: '#{arg}' not understood"
+          end
+        end
+
+        arity = args.size
+
+        return {
+          'return' => return_type,
+          'name'   => function_name,
+          'args'   => args,
+          'arity'  => arity
+        }
+      end
+
+      raise SyntaxError, "Can't parse signature: #{sig}"
+
+    end
+    
+    def generate_ffi(sig)
+
+      ffi_code = <<PREAMBLE
+extend FFI::Library
+ffi_lib '#{@fm.so_fn}'
+
+PREAMBLE
+
+      unless sig.nil?
+        sig.each do |s|
+          args = s['args'].map { |arg| ":#{to_ffi_type(arg)}" }.join(',')
+          ffi_code << "attach_function '#{s['name']}', [#{args}], :#{to_ffi_type(s['return'])}\n"
+        end
+      end
+
+      ffi_code
+    end
+    def write_c(code)
+      File.open(@fm.c_fn, 'w') { |f| f << code }
+    end
+
+    def write_ffi(sig)
+      File.open(@fm.rb_fn, 'w') { |f| f << generate_ffi(sig) }
+    end
+
+    def write_files(code, sig)
+      write_c(code)
+      write_ffi(sig)
+    end
+
+  end
+
+  def inline(code = "", options = {})
+    __inliner_make_directory
+    builder = Builder.new(self, code, options)
+    yield builder if block_given?
+    builder.build
+  end
+
+  private
+
+  def __inliner_make_directory
+    FileUtils.mkdir(Inliner.directory) unless (File.exists?(Inliner.directory) && File.directory?(Inliner.directory))
+  end
+
+end