webruby 0.2.7 → 0.9.1

data/modules/mruby/tasks/libmruby.rake

@@ -1,18 +1,22 @@
 MRuby.each_target do
   file libfile("#{build_dir}/lib/libmruby") => libmruby.flatten do |t|
     archiver.run t.name, t.prerequisites
-    open("#{build_dir}/lib/libmruby.flags.mak", 'w') do |f|
-      f.puts 'MRUBY_CFLAGS = %s' % cc.all_flags.gsub('"', '\\"') 
+  end
+
+  file "#{build_dir}/lib/libmruby.flags.mak" => [__FILE__, libfile("#{build_dir}/lib/libmruby")] do |t|
+    open(t.name, 'w') do |f|
+      f.puts "MRUBY_CFLAGS = #{cc.all_flags.gsub('"', '\\"')}"
 
       gem_flags = gems.map { |g| g.linker.flags }
       gem_library_paths = gems.map { |g| g.linker.library_paths }
-      f.puts 'MRUBY_LDFLAGS = %s' % linker.all_flags(gem_library_paths, gem_flags).gsub('"', '\\"') 
+      f.puts "MRUBY_LDFLAGS = #{linker.all_flags(gem_library_paths, gem_flags).gsub('"', '\\"')} #{linker.option_library_path % "#{build_dir}/lib"}"
 
       gem_flags_before_libraries = gems.map { |g| g.linker.flags_before_libraries }
-      f.puts 'MRUBY_LDFLAGS_BEFORE_LIBS = %s' % [linker.flags_before_libraries, gem_flags_before_libraries].flatten.join(' ').gsub('"', '\\"') 
+      f.puts "MRUBY_LDFLAGS_BEFORE_LIBS = #{[linker.flags_before_libraries, gem_flags_before_libraries].flatten.join(' ').gsub('"', '\\"')}"
 
       gem_libraries = gems.map { |g| g.linker.libraries }
-      f.puts 'MRUBY_LIBS = %s' % linker.library_flags(gem_libraries).gsub('"', '\\"') 
+      f.puts "MRUBY_LIBS = #{linker.option_library % 'mruby'} #{linker.library_flags(gem_libraries).gsub('"', '\\"')}"
     end
   end
+  task :all => "#{build_dir}/lib/libmruby.flags.mak"
 end

data/modules/mruby/tasks/mrbgem_spec.rake

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'forwardable'
+require 'tsort'
 
 module MRuby
   module Gem
@@ -31,7 +32,11 @@ module MRuby
       attr_accessor :bins
 
       attr_accessor :requirements
-      attr_reader :dependencies
+      attr_reader :dependencies, :conflicts
+
+      attr_accessor :export_include_paths
+
+      attr_reader :generate_functions
 
       attr_block MRuby::Build::COMMANDS
 
@@ -44,31 +49,33 @@ module MRuby
 
       def setup
         MRuby::Gem.current = self
-        @build.compilers.each do |compiler|
-          compiler.include_paths << "#{dir}/include"
-        end
         MRuby::Build::COMMANDS.each do |command|
           instance_variable_set("@#{command}", @build.send(command).clone)
         end
         @linker = LinkerConfig.new([], [], [], [])
 
         @rbfiles = Dir.glob("#{dir}/mrblib/*.rb").sort
-        @objs = Dir.glob("#{dir}/src/*.{c,cpp,cxx,m,asm,S}").map do |f|
+        @objs = Dir.glob("#{dir}/src/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
           objfile(f.relative_path_from(@dir).to_s.pathmap("#{build_dir}/%X"))
         end
-        @objs << objfile("#{build_dir}/gem_init")
+
+        @generate_functions = !(@rbfiles.empty? && @objs.empty?)
+        @objs << objfile("#{build_dir}/gem_init") if @generate_functions
 
         @test_rbfiles = Dir.glob("#{dir}/test/*.rb")
-        @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,m,asm,S}").map do |f|
+        @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
           objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X"))
         end
-        @test_preload = 'test/assert.rb'
+        @custom_test_init = !@test_objs.empty?
+        @test_preload = nil # 'test/assert.rb'
         @test_args = {}
 
         @bins = []
 
         @requirements = []
-        @dependencies = []
+        @dependencies, @conflicts = [], []
+        @export_include_paths = []
+        @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
 
         instance_eval(&@initializer)
 
@@ -82,15 +89,22 @@ module MRuby
 
         compilers.each do |compiler|
           compiler.define_rules build_dir, "#{dir}"
+          compiler.defines << %Q[MRBGEM_#{funcname.upcase}_VERSION=#{version}]
+          compiler.include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
         end
 
-        define_gem_init_builder
+        define_gem_init_builder if @generate_functions
       end
 
       def add_dependency(name, *requirements)
+        default_gem = requirements.last.kind_of?(Hash) ? requirements.pop : nil
         requirements = ['>= 0.0.0'] if requirements.empty?
         requirements.flatten!
-        @dependencies << {:gem => name, :requirements => requirements}
+        @dependencies << {:gem => name, :requirements => requirements, :default => default_gem}
+      end
+
+      def add_conflict(name, *req)
+        @conflicts << {:gem => name, :requirements => req.empty? ? nil : req}
       end
 
       def self.bin=(bin)
@@ -117,7 +131,7 @@ module MRuby
 
       def define_gem_init_builder
         file objfile("#{build_dir}/gem_init") => "#{build_dir}/gem_init.c"
-        file "#{build_dir}/gem_init.c" => [build.mrbcfile] + [rbfiles].flatten do |t|
+        file "#{build_dir}/gem_init.c" => [build.mrbcfile, __FILE__] + [rbfiles].flatten do |t|
           FileUtils.mkdir_p build_dir
           generate_gem_init("#{build_dir}/gem_init.c")
         end
@@ -169,12 +183,20 @@ module MRuby
 
       def print_gem_test_header(f)
         print_gem_comment(f)
+        f.puts %Q[#include <stdio.h>]
         f.puts %Q[#include <stdlib.h>]
         f.puts %Q[#include "mruby.h"]
-        f.puts %Q[#include "mruby/array.h"]
         f.puts %Q[#include "mruby/irep.h"]
-        f.puts %Q[#include "mruby/string.h"]
         f.puts %Q[#include "mruby/variable.h"]
+        f.puts %Q[#include "mruby/hash.h"] unless test_args.empty?
+      end
+
+      def test_dependencies
+        [@name]
+      end
+
+      def custom_test_init?
+        @custom_test_init
       end
 
       def version_ok?(req_versions)
@@ -276,27 +298,109 @@ module MRuby
         @ary.empty?
       end
 
-      def check
+      def generate_gem_table build
+        gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res }
+
+        default_gems = []
+        each do |g|
+          g.dependencies.each do |dep|
+            default_gems << dep if dep[:default] and not gem_table.key? dep[:gem]
+          end
+        end
+
+        until default_gems.empty?
+          def_gem = default_gems.pop
+
+          spec = build.gem def_gem[:default]
+          fail "Invalid gem name: #{spec.name} (Expected: #{def_gem[:gem]})" if spec.name != def_gem[:gem]
+          spec.setup
+
+          spec.dependencies.each do |dep|
+            default_gems << dep if dep[:default] and not gem_table.key? dep[:gem]
+          end
+          gem_table[spec.name] = spec
+        end
+
         each do |g|
           g.dependencies.each do |dep|
             name = dep[:gem]
             req_versions = dep[:requirements]
+            dep_g = gem_table[name]
 
             # check each GEM dependency against all available GEMs
-            found_dep_gem = false
-            each do |dep_g|
-              if name == dep_g.name
-                unless dep_g.version_ok?(req_versions)
-                  fail "#{name} version should be #{req_versions.join(' and ')} but was '#{dep_g.version}'"
-                end
-
-                found_dep_gem = true
-                break
-              end
+            if dep_g.nil?
+              fail "The GEM '#{g.name}' depends on the GEM '#{name}' but it could not be found"
             end
+            unless dep_g.version_ok? req_versions
+              fail "#{name} version should be #{req_versions.join(' and ')} but was '#{dep_g.version}'"
+            end
+          end
 
-            fail "The GEM '#{g.name}' depends on the GEM '#{name}' but it could not be found" unless found_dep_gem
+          cfls = g.conflicts.select { |c|
+            cfl_g = gem_table[c[:gem]]
+            cfl_g and cfl_g.version_ok?(c[:requirements] || ['>= 0.0.0'])
+          }.map { |c| "#{c[:gem]}(#{gem_table[c[:gem]].version})" }
+          fail "Conflicts of gem `#{g.name}` found: #{cfls.join ', '}" unless cfls.empty?
+        end
+
+        gem_table
+      end
+
+      def tsort_dependencies ary, table, all_dependency_listed = false
+        unless all_dependency_listed
+          left = ary.dup
+          until left.empty?
+            v = left.pop
+            table[v].dependencies.each do |dep|
+              left.push dep[:gem]
+              ary.push dep[:gem]
+            end
+          end
+        end
+
+        ary.uniq!
+        table.instance_variable_set :@root_gems, ary
+        class << table
+          include TSort
+          def tsort_each_node &b
+            @root_gems.each &b
+          end
+
+          def tsort_each_child(n, &b)
+            fetch(n).dependencies.each do |v|
+              b.call v[:gem]
+            end
+          end
+        end
+
+        begin
+          table.tsort.map { |v| table[v] }
+        rescue TSort::Cyclic => e
+          fail "Circular mrbgem dependency found: #{e.message}"
+        end
+      end
+
+      def check(build)
+        gem_table = generate_gem_table build
+
+        @ary = tsort_dependencies gem_table.keys, gem_table, true
+
+        each do |g|
+          import_include_paths(g)
+        end
+      end
 
+      def import_include_paths(g)
+        gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res }
+        g.dependencies.each do |dep|
+          dep_g = gem_table[dep[:gem]]
+          # We can do recursive call safely
+          # as circular dependency has already detected in the caller.
+          import_include_paths(dep_g)
+
+          g.compilers.each do |compiler|
+            compiler.include_paths += dep_g.export_include_paths
+            g.export_include_paths += dep_g.export_include_paths
           end
         end
       end

data/modules/mruby/tasks/mrbgems.rake

@@ -2,14 +2,25 @@ MRuby.each_target do
   if enable_gems?
     # set up all gems
     gems.each(&:setup)
-    gems.check
+    gems.check self
 
     # loader all gems
     self.libmruby << objfile("#{build_dir}/mrbgems/gem_init")
     file objfile("#{build_dir}/mrbgems/gem_init") => ["#{build_dir}/mrbgems/gem_init.c", "#{build_dir}/LEGAL"]
-    file "#{build_dir}/mrbgems/gem_init.c" => [MRUBY_CONFIG] do |t|
+    file "#{build_dir}/mrbgems/gem_init.c" => [MRUBY_CONFIG, __FILE__] do |t|
       FileUtils.mkdir_p "#{build_dir}/mrbgems"
       open(t.name, 'w') do |f|
+        gem_func_gems = gems.select { |g| g.generate_functions }
+        gem_func_decls = gem_func_gems.each_with_object('') do |g, s|
+          s << "void GENERATED_TMP_mrb_#{g.funcname}_gem_init(mrb_state*);\n" \
+               "void GENERATED_TMP_mrb_#{g.funcname}_gem_final(mrb_state*);\n"
+        end
+        gem_init_calls = gem_func_gems.each_with_object('') do |g, s|
+          s << "  GENERATED_TMP_mrb_#{g.funcname}_gem_init(mrb);\n"
+        end
+        gem_final_calls = gem_func_gems.each_with_object('') do |g, s|
+          s << "  GENERATED_TMP_mrb_#{g.funcname}_gem_final(mrb);\n"
+        end
         f.puts %Q[/*]
         f.puts %Q[ * This file contains a list of all]
         f.puts %Q[ * initializing methods which are]
@@ -22,25 +33,24 @@ MRuby.each_target do
         f.puts %Q[]
         f.puts %Q[#include "mruby.h"]
         f.puts %Q[]
-        f.puts %Q[#{gems.map{|g| "void GENERATED_TMP_mrb_%s_gem_init(mrb_state* mrb);" % g.funcname}.join("\n")}]
+        f.write gem_func_decls
         f.puts %Q[]
-        f.puts %Q[#{gems.map{|g| "void GENERATED_TMP_mrb_%s_gem_final(mrb_state* mrb);" % g.funcname}.join("\n")}]
-        f.puts %Q[]
-        f.puts %Q[void]
-        f.puts %Q[mrb_init_mrbgems(mrb_state *mrb) {]
-        f.puts %Q[#{gems.map{|g| "GENERATED_TMP_mrb_%s_gem_init(mrb);" % g.funcname}.join("\n")}]
+        f.puts %Q[static void]
+        f.puts %Q[mrb_final_mrbgems(mrb_state *mrb) {]
+        f.write gem_final_calls
         f.puts %Q[}]
         f.puts %Q[]
         f.puts %Q[void]
-        f.puts %Q[mrb_final_mrbgems(mrb_state *mrb) {]
-        f.puts %Q[#{gems.map{|g| "GENERATED_TMP_mrb_%s_gem_final(mrb);" % g.funcname}.join("\n")}]
+        f.puts %Q[mrb_init_mrbgems(mrb_state *mrb) {]
+        f.write gem_init_calls
+        f.puts %Q[  mrb_state_atexit(mrb, mrb_final_mrbgems);] unless gem_final_calls.empty?
         f.puts %Q[}]
       end
     end
   end
 
   # legal documents
-  file "#{build_dir}/LEGAL" => [MRUBY_CONFIG] do |t|
+  file "#{build_dir}/LEGAL" => [MRUBY_CONFIG, __FILE__] do |t|
     open(t.name, 'w+') do |f|
      f.puts <<LEGAL
 Copyright (c) #{Time.now.year} mruby developers

data/modules/mruby/tasks/mrbgems_test.rake

@@ -1,42 +1,71 @@
 MRuby.each_target do
+  gem_table = gems.generate_gem_table self
+
   gems.each do |g|
     test_rbobj = g.test_rbireps.ext(exts.object)
+    g.test_objs << test_rbobj
+    dep_list = gems.tsort_dependencies(g.test_dependencies, gem_table).select(&:generate_functions)
 
     file test_rbobj => g.test_rbireps
-    file g.test_rbireps => [g.test_rbfiles].flatten + [g.build.mrbcfile] do |t|
+    file g.test_rbireps => [g.test_rbfiles].flatten + [File.join(g.dir, 'mrbgem.rake'), g.build.mrbcfile, __FILE__, "#{MRUBY_ROOT}/tasks/mrbgem_spec.rake"] do |t|
+      FileUtils.mkdir_p File.dirname(t.name)
       open(t.name, 'w') do |f|
         g.print_gem_test_header(f)
-        test_preload = [g.dir, MRUBY_ROOT].map {|dir|
+        test_preload = g.test_preload and [g.dir, MRUBY_ROOT].map {|dir|
           File.expand_path(g.test_preload, dir)
         }.find {|file| File.exist?(file) }
 
-        g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload"
+        f.puts %Q[/*]
+        f.puts %Q[ * This file contains a test code for #{g.name} gem.]
+        f.puts %Q[ *]
+        f.puts %Q[ * IMPORTANT:]
+        f.puts %Q[ *   This file was generated!]
+        f.puts %Q[ *   All manual changes will get lost.]
+        f.puts %Q[ */]
+        if test_preload.nil?
+          f.puts %Q[extern const uint8_t mrbtest_assert_irep[];]
+        else
+          g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload"
+        end
         g.test_rbfiles.flatten.each_with_index do |rbfile, i|
           g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}"
         end
         f.puts %Q[void mrb_#{g.funcname}_gem_test(mrb_state *mrb);] unless g.test_objs.empty?
+        dep_list.each do |d|
+          f.puts %Q[void GENERATED_TMP_mrb_#{d.funcname}_gem_init(mrb_state *mrb);]
+          f.puts %Q[void GENERATED_TMP_mrb_#{d.funcname}_gem_final(mrb_state *mrb);]
+        end
+        f.puts %Q[void mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose);]
+        f.puts %Q[void mrb_t_pass_result(mrb_state *dst, mrb_state *src);]
         f.puts %Q[void GENERATED_TMP_mrb_#{g.funcname}_gem_test(mrb_state *mrb) {]
         unless g.test_rbfiles.empty?
           f.puts %Q[  mrb_state *mrb2;]
-          if g.test_args.empty?
-            f.puts %Q[  mrb_value val1, val2, val3, ary1, ary2;]
-          else
-            f.puts %Q[  mrb_value val1, val2, val3, ary1, ary2, test_args_hash;]
+          unless g.test_args.empty?
+            f.puts %Q[  mrb_value test_args_hash;]
           end
           f.puts %Q[  int ai;]
           g.test_rbfiles.count.times do |i|
             f.puts %Q[  ai = mrb_gc_arena_save(mrb);]
-            f.puts %Q[  mrb2 = mrb_open();]
-            f.puts %Q[  val3 = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_verbose"));]
-            f.puts %Q[  if (mrb_test(val3)) {]
-            f.puts %Q[    mrb_gv_set(mrb2, mrb_intern_cstr(mrb2, "$mrbtest_verbose"), val3);]
+            f.puts %Q[  mrb2 = mrb_open_core(mrb_default_allocf, NULL);]
+            f.puts %Q[  if (mrb2 == NULL) {]
+            f.puts %Q[    fprintf(stderr, "Invalid mrb_state, exiting \%s", __FUNCTION__);]
+            f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
-            f.puts %Q[  mrb_load_irep(mrb2, gem_test_irep_#{g.funcname}_preload);]
+            dep_list.each do |d|
+              f.puts %Q[  GENERATED_TMP_mrb_#{d.funcname}_gem_init(mrb2);]
+              f.puts %Q[  mrb_state_atexit(mrb2, GENERATED_TMP_mrb_#{d.funcname}_gem_final);]
+            end
+            f.puts %Q[  mrb_init_test_driver(mrb2, mrb_test(mrb_gv_get(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"))));]
+            if test_preload.nil?
+              f.puts %Q[  mrb_load_irep(mrb2, mrbtest_assert_irep);]
+            else
+              f.puts %Q[  mrb_load_irep(mrb2, gem_test_irep_#{g.funcname}_preload);]
+            end
             f.puts %Q[  if (mrb2->exc) {]
-            f.puts %Q[    mrb_p(mrb2, mrb_obj_value(mrb2->exc));]
+            f.puts %Q[    mrb_print_error(mrb2);]
             f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
-            f.puts %Q[  mrb_const_set(mrb2, mrb_obj_value(mrb2->object_class), mrb_intern_cstr(mrb2, "GEMNAME"), mrb_str_new(mrb2, "#{g.name}", #{g.name.length}));]
+            f.puts %Q[  mrb_const_set(mrb2, mrb_obj_value(mrb2->object_class), mrb_intern_lit(mrb2, "GEMNAME"), mrb_str_new(mrb2, "#{g.name}", #{g.name.length}));]
 
             unless g.test_args.empty?
               f.puts %Q[  test_args_hash = mrb_hash_new_capa(mrb, #{g.test_args.length}); ]
@@ -45,37 +74,15 @@ MRuby.each_target do
                 escaped_arg_value = arg_value.gsub('\\', '\\\\\\\\').gsub('"', '\"')
                 f.puts %Q[  mrb_hash_set(mrb2, test_args_hash, mrb_str_new(mrb2, "#{escaped_arg_name.to_s}", #{escaped_arg_name.to_s.length}), mrb_str_new(mrb2, "#{escaped_arg_value.to_s}", #{escaped_arg_value.to_s.length})); ]
               end
-              f.puts %Q[  mrb_const_set(mrb2, mrb_obj_value(mrb2->object_class), mrb_intern_cstr(mrb2, "TEST_ARGS"), test_args_hash); ]
+              f.puts %Q[  mrb_const_set(mrb2, mrb_obj_value(mrb2->object_class), mrb_intern_lit(mrb2, "TEST_ARGS"), test_args_hash); ]
             end
 
-            f.puts %Q[  mrb_#{g.funcname}_gem_test(mrb2);] unless g.test_objs.empty?
+            f.puts %Q[  mrb_#{g.funcname}_gem_test(mrb2);] if g.custom_test_init?
 
             f.puts %Q[  mrb_load_irep(mrb2, gem_test_irep_#{g.funcname}_#{i});]
-            f.puts %Q[  if (mrb2->exc) {]
-            f.puts %Q[    mrb_p(mrb2, mrb_obj_value(mrb2->exc));]
-            f.puts %Q[    exit(EXIT_FAILURE);]
-            f.puts %Q[  }]
             f.puts %Q[  ]
 
-            %w(ok_test ko_test kill_test).each do |vname|
-              f.puts %Q[  val2 = mrb_gv_get(mrb2, mrb_intern_cstr(mrb2, "$#{vname}"));]
-              f.puts %Q[  if (mrb_fixnum_p(val2)) {]
-              f.puts %Q[    val1 = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$#{vname}"));]
-              f.puts %Q[    mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$#{vname}"), mrb_fixnum_value(mrb_fixnum(val1) + mrb_fixnum(val2)));]
-              f.puts %Q[  }\n]
-            end
-
-            f.puts %Q[  ary2 = mrb_gv_get(mrb2, mrb_intern_cstr(mrb2, "$asserts"));]
-            f.puts %Q[  if (mrb_test(ary2)) {]
-            f.puts %Q[    ary1 = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$asserts"));]
-            f.puts %Q[    val2 = mrb_ary_shift(mrb2, ary2);]
-            f.puts %Q[    ]
-            f.puts %Q[    while (mrb_test(val2)) {]
-            f.puts %Q[      char *str = mrb_string_value_cstr(mrb2, &val2);]
-            f.puts %Q[      mrb_ary_push(mrb, ary1, mrb_str_new_cstr(mrb, str));]
-            f.puts %Q[      val2 = mrb_ary_shift(mrb2, ary2);]
-            f.puts %Q[    }]
-            f.puts %Q[  }]
+            f.puts %Q[  mrb_t_pass_result(mrb, mrb2);]
             f.puts %Q[  mrb_close(mrb2);]
             f.puts %Q[  mrb_gc_arena_restore(mrb, ai);]
           end
@@ -83,6 +90,5 @@ MRuby.each_target do
         f.puts %Q[}]
       end
     end
-
   end
 end

data/modules/mruby/tasks/mruby_build.rake

@@ -44,7 +44,8 @@ module MRuby
     include Rake::DSL
     include LoadGems
     attr_accessor :name, :bins, :exts, :file_separator, :build_dir, :gem_clone_dir
-    attr_reader :libmruby, :gems
+    attr_reader :libmruby, :gems, :toolchains
+    attr_writer :enable_bintest
 
     COMPILERS = %w(cc cxx objc asm)
     COMMANDS = COMPILERS + %w(linker archiver yacc gperf git exts mrbc)
@@ -52,7 +53,7 @@ module MRuby
 
     Exts = Struct.new(:object, :executable, :library)
 
-    def initialize(name='host', &block)
+    def initialize(name='host', build_dir=nil, &block)
       @name = name.to_s
 
       unless MRuby.targets[@name]
@@ -62,9 +63,11 @@ module MRuby
           @exts = Exts.new('.o', '', '.a')
         end
 
+        build_dir = build_dir || ENV['MRUBY_BUILD_DIR'] || "#{MRUBY_ROOT}/build"
+
         @file_separator = '/'
-        @build_dir = "#{MRUBY_ROOT}/build/#{@name}"
-        @gem_clone_dir = "#{MRUBY_ROOT}/build/mrbgems"
+        @build_dir = "#{build_dir}/#{@name}"
+        @gem_clone_dir = "#{build_dir}/mrbgems"
         @cc = Command::Compiler.new(self, %w(.c))
         @cxx = Command::Compiler.new(self, %w(.cc .cxx .cpp))
         @objc = Command::Compiler.new(self, %w(.m))
@@ -79,6 +82,9 @@ module MRuby
         @bins = %w(mrbc)
         @gems, @libmruby = MRuby::Gem::List.new, []
         @build_mrbtest_lib_only = false
+        @cxx_abi_enabled = false
+        @cxx_exception_disabled = false
+        @toolchains = []
 
         MRuby.targets[@name] = self
       end
@@ -92,10 +98,38 @@ module MRuby
       @mrbc.compile_options += ' -g'
     end
 
+    def disable_cxx_exception
+      @cxx_exception_disabled = true
+    end
+
+    def cxx_abi_enabled?
+      @cxx_abi_enabled
+    end
+
+    def enable_cxx_abi
+      return if @cxx_exception_disabled or @cxx_abi_enabled
+      compilers.each { |c| c.defines += %w(MRB_ENABLE_CXX_EXCEPTION) }
+      linker.command = cxx.command if toolchains.find { |v| v == 'gcc' }
+      @cxx_abi_enabled = true
+    end
+
+    def enable_bintest
+      @enable_bintest = true
+    end
+
+    def bintest_enabled?
+      @enable_bintest
+    end
+
     def toolchain(name)
       tc = Toolchain.toolchains[name.to_s]
       fail "Unknown #{name} toolchain" unless tc
       tc.setup(self)
+      @toolchains.unshift name.to_s
+    end
+
+    def primary_toolchain
+      @toolchains.first
     end
 
     def root
@@ -115,9 +149,9 @@ module MRuby
     def define_rules
       compilers.each do |compiler|
         if respond_to?(:enable_gems?) && enable_gems?
-          compiler.defines -= %w(DISABLE_GEMS) 
+          compiler.defines -= %w(DISABLE_GEMS)
         else
-          compiler.defines += %w(DISABLE_GEMS) 
+          compiler.defines += %w(DISABLE_GEMS)
         end
         compiler.define_rules build_dir, File.expand_path(File.join(File.dirname(__FILE__), '..'))
       end
@@ -175,7 +209,14 @@ module MRuby
       puts ">>> Test #{name} <<<"
       mrbtest = exefile("#{build_dir}/test/mrbtest")
       sh "#{filename mrbtest.relative_path}#{$verbose ? ' -v' : ''}"
-      puts 
+      puts
+      run_bintest if @enable_bintest
+    end
+
+    def run_bintest
+      targets = @gems.select { |v| File.directory? "#{v.dir}/bintest" }.map { |v| filename v.dir }
+      targets << filename(".") if File.directory? "./bintest"
+      sh "ruby test/bintest.rb #{targets.join ' '}"
     end
 
     def print_build_summary
@@ -186,8 +227,9 @@ module MRuby
       unless @gems.empty?
         puts "    Included Gems:"
         @gems.map do |gem|
-          gem_version = "- #{gem.version}" if gem.version
-          puts "             #{gem.name} #{gem_version}"
+          gem_version = " - #{gem.version}" if gem.version != '0.0.0'
+          gem_summary = " - #{gem.summary}" if gem.summary
+          puts "             #{gem.name}#{gem_version}#{gem_summary}"
           puts "               - Binaries: #{gem.bins.join(', ')}" unless gem.bins.empty?
         end
       end
@@ -199,9 +241,9 @@ module MRuby
   class CrossBuild < Build
     attr_block %w(test_runner)
 
-    def initialize(name, &block)
-  @test_runner = Command::CrossTestRunner.new(self)
-  super
+    def initialize(name, build_dir=nil, &block)
+      @test_runner = Command::CrossTestRunner.new(self)
+      super
     end
 
     def mrbcfile

data/modules/mruby/tasks/mruby_build_commands.rake

@@ -24,9 +24,17 @@ module MRuby
       target
     end
 
+    NotFoundCommands = {}
+
     private
     def _run(options, params={})
-      sh build.filename(command) + ' ' + ( options % params )
+      return sh command + ' ' + ( options % params ) if NotFoundCommands.key? @command
+      begin
+        sh build.filename(command) + ' ' + ( options % params )
+      rescue RuntimeError
+        NotFoundCommands[@command] = true
+        _run options, params
+      end
     end
   end
 
@@ -46,6 +54,18 @@ module MRuby
       @compile_options = '%{flags} -o %{outfile} -c %{infile}'
     end
 
+    alias header_search_paths include_paths
+    def search_header_path(name)
+      header_search_paths.find do |v|
+        File.exist? build.filename("#{v}/#{name}").sub(/^"(.*)"$/, '\1')
+      end
+    end
+
+    def search_header(name)
+      path = search_header_path name
+      path && build.filename("#{path}/#{name}").sub(/^"(.*)"$/, '\1')
+    end
+
     def all_flags(_defineds=[], _include_paths=[], _flags=[])
       define_flags = [defines, _defineds].flatten.map{ |d| option_define % d }
       include_path_flags = [include_paths, _include_paths].flatten.map do |f|
@@ -110,7 +130,7 @@ module MRuby
         File.read(file).gsub("\\\n ", "").scan(/^\S+:\s+(.+)$/).flatten.map {|s| s.split(' ') }.flatten
       else
         []
-      end
+      end + [ MRUBY_CONFIG ]
     end
   end
 
@@ -220,14 +240,15 @@ module MRuby
 
   class Command::Git < Command
     attr_accessor :flags
-    attr_accessor :clone_options, :pull_options
+    attr_accessor :clone_options, :pull_options, :checkout_options
 
     def initialize(build)
       super
       @command = 'git'
-      @flags = []
+      @flags = %w[]
       @clone_options = "clone %{flags} %{url} %{dir}"
       @pull_options = "pull"
+      @checkout_options = "checkout %{checksum_hash}"
     end
 
     def run_clone(dir, url, _flags = [])
@@ -242,6 +263,14 @@ module MRuby
       _run pull_options
       Dir.chdir root
     end
+
+    def run_checkout(dir, checksum_hash)
+      root = Dir.pwd
+      Dir.chdir dir
+      _pp "GIT CHECKOUT", checksum_hash
+      _run checkout_options, { :checksum_hash => checksum_hash }
+      Dir.chdir root
+    end
   end
 
   class Command::Mrbc < Command
@@ -263,7 +292,7 @@ module MRuby
         out.puts io.read
       end
       # if mrbc execution fail, drop the file
-      unless $?.exitstatus
+      if $?.exitstatus != 0
         File.delete(out.path)
         exit(-1)
       end