ffi-inliner 0.2.2 → 0.2.3

data/.gitignore

@@ -3,4 +3,5 @@
 ^#
 pkg
 announcement.txt
+cache
 

data/History.txt

@@ -1,3 +1,18 @@
+== 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

data/README.rdoc

@@ -10,11 +10,11 @@ With ffi-inliner you can run C code within your ruby script.
 
 * 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 implementation!
+  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)
+  that don't support tcc (e.g. OSX) or that don't have it installed
 
 == SYNOPSIS:
 
@@ -34,7 +34,9 @@ With ffi-inliner you can run C code within your ruby script.
   Foo.new.say_hello('foos')
 
 For other hints see the examples/ folder or visit the
-wiki[http://wiki.github.com/remogatto/ffi-inliner/tutorial]
+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:
 

data/Rakefile

@@ -26,11 +26,11 @@ PROJ.version = Inliner::VERSION
 
 PROJ.readme_file = 'README.rdoc'
 
-PROJ.rubyforge.name = 'ffi'
+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] << 'dev@ruby-ffi.kenai.com' << 'users@ruby-ffi.kenai.com'
+PROJ.ann.email[:to] << 'ruby-ffi@googlegroups.com'
 PROJ.ann.email[:server] = 'smtp.gmail.com'
 
 PROJ.spec.opts << '--color' << '-fs'

data/lib/ffi-inliner/inliner.rb

@@ -59,21 +59,26 @@ module Inliner
   module Compilers
     class Compiler
       attr_reader :progname
-      def self.check_and_create(fm = nil)
-        compiler = new(fm) 
+      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)
+      def initialize(fm = nil, libraries = nil)
         @fm = fm
+        @libraries = libraries
         @progname = cmd.split.first
       end
       def compile
         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
@@ -88,7 +93,17 @@ module Inliner
         end
       end
       def cmd
-        "#{ldshared} -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\" 2>\"#{@fm.log_fn}\""
+        "#{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'
+        else
+          'g++ -shared -fPIC'
+        end
       end
     end
 
@@ -97,29 +112,41 @@ module Inliner
         IO.popen("#{@progname}") { |f| f.gets } ? true : false
       end
       def cmd
-        "tcc -shared -o \"#{@fm.so_fn}\" \"#{@fm.c_fn}\" 2>\"#{@fm.log_fn}\""
+        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
+    attr_reader :code, :compiler
     def initialize(mod, code = "", options = {})
       make_pointer_types
       @mod = mod
       @code = code
       @sig = [parse_signature(@code)] unless @code.empty?
-      options = { :compiler => Compilers::GCC }.merge(options)
-      @compiler = options[:compiler]
+      options = { :use_compiler => Compilers::GCC }.merge(options)
+      @compiler = options[:use_compiler]
     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 << code 
+      @code << (@compiler == Compilers::GPlusPlus ? "extern \"C\" {\n#{code}\n}" : code )
     end
 
     def c_raw(code)
@@ -130,9 +157,17 @@ module Inliner
       @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)
-      @compiler = @compiler.check_and_create(@fm)
+      @compiler = @compiler.check_and_create(@fm, @libraries)
       unless @fm.cached?
         write_files(@code, @sig)
         @compiler.compile
@@ -173,14 +208,16 @@ module Inliner
     # 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
@@ -215,15 +252,20 @@ module Inliner
     end
     
     def generate_ffi(sig)
+
       ffi_code = <<PREAMBLE
 extend FFI::Library
 ffi_lib '#{@fm.so_fn}'
 
 PREAMBLE
-      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"
+
+      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)

data/lib/ffi-inliner/version.rb

@@ -1,3 +1,3 @@
 module Inliner
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

data/spec/ffi-inliner/inliner_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "../spec_helper"))
 
-describe Inliner do
+describe 'Inliner' do
 
   before do
     module Foo
@@ -75,7 +75,7 @@ describe Inliner do
 
   end
 
-   it 'should be configured using the block form' do
+  it 'should be configured using the block form' do
     module Foo
       inline do |builder|
         builder.c %q{
@@ -114,6 +114,27 @@ describe Inliner do
     my_struct = MyStruct.new
     Foo.use_my_struct(my_struct).should == my_struct.to_ptr
   end
+
+  it 'should allow users to include header files' do
+    module Foo
+      inline do |builder|
+        builder.include "stdio.h"
+        builder.include "local_header.h", :quoted => true
+        builder.code.should == "#include <stdio.h>\n#include \"local_header.h\"\n"
+        builder.stub!(:build)
+      end
+    end
+  end
+
+  it 'should allow users to add libraries' do
+    module Foo
+      inline do |builder|
+        builder.library 'foolib1', 'foolib2'
+        builder.stub!(:build)
+      end
+    end
+  end
+
   it 'should generate C struct from FFI::Struct' do
     pending do
       class MyStruct < FFI::Struct
@@ -138,24 +159,32 @@ EOC
       end
     end
   end
-#   it 'should use different compiler as specified in the configuration block' do
-#     tcc = mock('tcc', :exists? => true, :compile => nil)
-#     Inliner::Compilers::TCC.should_receive(:new).and_return(tcc)
-#     module Foo
-#       inline do |builder|
-#         builder.code = "int func_1() { return 0; }"
-#         builder.compiler = Inliner::Compilers::TCC
-#       end
-#     end
-#   end
-
-#   it 'should be configured using the hash form' do
-#     tcc = mock('tcc', :exists? => true, :compile => nil)
-#     Inliner::Compilers::TCC.should_receive(:new).and_return(tcc)
-#     module Foo
-#       inline "int func_1() { return 1; }", :compiler => Inliner::Compilers::TCC
-#     end
-#   end
+
+  it 'should use different compiler as specified in the configuration block' do
+    module Foo
+      inline do |builder|
+        builder.use_compiler Inliner::Compilers::TCC
+        builder.c "int func_1() { return 1 + 1; }"
+      end
+    end
+    Foo.func_1.should == 2
+  end
+
+  it 'should return the current compiler' do
+    module Foo
+      inline do |builder|
+        builder.compiler.should == Inliner::Compilers::GCC
+      end
+    end
+  end
+
+  #   it 'should be configured using the hash form' do
+  #     tcc = mock('tcc', :exists? => true, :compile => nil)
+  #     Inliner::Compilers::TCC.should_receive(:new).and_return(tcc)
+  #     module Foo
+  #       inline "int func_1() { return 1; }", :compiler => Inliner::Compilers::TCC
+  #     end
+  #   end
 
   it 'should raise errors' do
     lambda {
@@ -169,18 +198,55 @@ EOC
       end
     }.should raise_error(/Compile error/)
   end
-  
-end
 
-describe Inliner::Compilers::Compiler do
-  before do
-    class DummyCC < Inliner::Compilers::Compiler
-      def cmd
-        "dummycc -shared"
+  describe 'Compiler' do
+    before do
+      class DummyCC < Inliner::Compilers::Compiler
+        def cmd
+          "dummycc -shared"
+        end
       end
     end
+    it 'should return the progname' do
+      DummyCC.new.progname.should == 'dummycc'
+    end
   end
-  it 'should return the progname' do
-    DummyCC.new.progname.should == 'dummycc'
+
+  describe 'GPlusPlus compiler' do
+    
+    it 'should compile and link a shim C library that encapsulates C++ code' do
+
+      module Foo
+        inline do |builder|
+          builder.use_compiler Inliner::Compilers::GPlusPlus
+          builder.c_raw <<-code
+            #include <iostream>
+            #include <string>
+            using namespace std;
+            class Greeter  {
+                public:
+                Greeter();
+                string say_hello();
+              };
+              Greeter::Greeter() { };
+              string Greeter::say_hello() {
+                return "Hello foos!";
+              };
+              code
+              builder.map 'char *' => 'string'
+              builder.c <<-code
+              const char* say_hello()
+              { 
+                Greeter greeter;
+                return greeter.say_hello().c_str();
+              }
+            code
+        end
+      end
+      Foo.say_hello.should == 'Hello foos!'
+    end
+
   end
+
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ffi-inliner
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - Andrea Fazzi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-05 00:00:00 +02:00
+date: 2009-12-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,8 +89,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: ffi
-rubygems_version: 1.3.4
+rubyforge_project: ffi-inliner
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: With ffi-inliner you can run C code within your ruby script