script_core 0.2.5 → 0.3.2

data/ext/enterprise_script_service/mruby/tasks/benchmark.rake

@@ -5,14 +5,14 @@ end
 $dat_files = []
 
 def bm_files
-  Dir.glob("#{MRUBY_ROOT}/benchmark/bm_*.rb")
+  Dir.glob("#{MRUBY_ROOT}/benchmark/bm_*.rb").sort
 end
 
 def build_config_name
-  if ENV['MRUBY_CONFIG']
+  if !ENV['MRUBY_CONFIG'].to_s.empty?
     File.basename(ENV['MRUBY_CONFIG'], '.rb').gsub('build_config_', '')
   else
-    "build"
+    "bm"
   end
 end
 
@@ -50,7 +50,7 @@ end
 
 
 MRuby.each_target do |target|
-  next if target.name == 'host'
+  next if target.name == 'host' || target.internal?
   mruby_bin = "#{target.build_dir}/bin/mruby"
 
   bm_files.each do |bm_file|
@@ -67,8 +67,8 @@ MRuby.each_target do |target|
       puts "..."
 
       data = (0...MRuby::BENCHMARK_REPEAT).map do |n|
-        str = %x{(time -f "%e %S %U" #{mruby_bin} #{bm_file}) 2>&1 >/dev/null}
-        str.split(' ').map(&:to_f)
+        str = %x{(time -p #{mruby_bin} #{bm_file}) 2>&1 >/dev/null}
+        str.scan(/\d+\.\d+$/).map(&:to_f) # [real, user, sys]
       end
 
       File.open(task.name, "w") do |f|

data/ext/enterprise_script_service/mruby/tasks/bin.rake

@@ -0,0 +1,23 @@
+MRuby.each_target do |build|
+  if build.host? && build.mrbc_build && !build.gems["mruby-bin-mrbc"]
+    exe = build.exefile("#{build.mrbc_build.build_dir}/bin/mrbc")
+    build.products << build.define_installer(exe)
+  end
+
+  build.bins.each{|bin| build.products << define_installer_if_needed(bin)}
+
+  linker_attrs = build.gems.linker_attrs
+  build.gems.each do |gem|
+    gem.bins.each do |bin|
+      exe = build.exefile("#{build.build_dir}/bin/#{bin}")
+      objs = Dir["#{gem.dir}/tools/#{bin}/*.{c,cpp,cxx,cc}"].map do |f|
+        build.objfile(f.pathmap("#{gem.build_dir}/tools/#{bin}/%n"))
+      end
+      file exe => objs.concat(build.libraries) do |t|
+        build.linker.run t.name, t.prerequisites, *linker_attrs
+      end
+
+      build.products << define_installer_if_needed(bin)
+    end
+  end
+end

data/ext/enterprise_script_service/mruby/tasks/core.rake

@@ -0,0 +1,12 @@
+as_cxx_srcs = %w[vm error gc].map{|name| "#{MRUBY_ROOT}/src/#{name}.c"}
+
+MRuby.each_target do
+  objs = Dir.glob("#{MRUBY_ROOT}/src/*.c").map do |src|
+    if cxx_exception_enabled? && as_cxx_srcs.include?(src)
+      compile_as_cxx(src)
+    else
+      objfile(src.pathmap("#{build_dir}/src/%n"))
+    end
+  end
+  self.libmruby_core_objs << objs
+end

data/ext/enterprise_script_service/mruby/tasks/doc.rake

@@ -1,48 +1,60 @@
 desc 'generate document'
-task :doc => [:api_doc, :capi_doc] do
-
-end
-
-desc 'generate yard docs'
-task :api_doc do
-  begin
-    sh "mrbdoc"
-  rescue
-    puts "ERROR: To generate yard documentation, you should install yard-mruby gem."
-    puts "  $ gem install yard-mruby yard-coderay"
+task :doc => %w[doc:api doc:capi]
+
+namespace :doc do
+  desc 'generate yard docs'
+  task :api do
+    begin
+      sh "mrbdoc"
+    rescue
+      puts "ERROR: To generate yard documentation, you should install yard-mruby gem."
+      puts "  $ gem install yard-mruby yard-coderay"
+    end
   end
-end
 
-desc 'generate doxygen docs'
-task :capi_doc do
-  begin
-    sh "doxygen Doxyfile"
-  rescue
-    puts "ERROR: To generate C API documents, you need Doxygen."
-    puts "  $ sudo apt-get install doxygen"
+  desc 'generate doxygen docs'
+  task :capi do
+    begin
+      sh "doxygen Doxyfile"
+    rescue
+      puts "ERROR: To generate C API documents, you need Doxygen."
+      puts "  $ sudo apt-get install doxygen"
+    end
   end
-end
 
-desc 'clean all built docs'
-task :clean_api_doc do
-  rm_rf 'doc/api'
-end
+  desc 'clean all built docs'
+  task :clean => %w[clean:api clean:capi]
 
-desc 'clean all built docs'
-task :clean_capi_doc do
-  rm_rf 'doc/capi'
-end
+  namespace :clean do
+    desc 'clean yard docs'
+    task :api do
+      rm_rf 'doc/api'
+    end
 
-desc 'clean all built docs'
-task :clean_doc => [:clean_api_doc, :clean_capi_doc] do
-end
+    desc 'clean doxygen docs'
+    task :capi do
+      rm_rf 'doc/capi'
+    end
+  end
 
-desc 'clean all built docs'
-task :view_api => [:api_doc] do
-  sh 'xdg-open doc/api/index.html'
-end
+  namespace :view do
+    desc 'open yard docs'
+    task :api do
+      sh 'xdg-open doc/api/index.html'
+    end
 
-desc 'clean all built docs'
-task :view_capi => [:capi_doc] do
-  sh 'xdg-open doc/capi/html/index.html'
+    desc 'open doxygen docs'
+    task :capi do
+      sh 'xdg-open doc/capi/html/index.html'
+    end
+  end
 end
+
+# deprecated
+task "api_doc" => "doc:api"
+task "capi_doc" => "doc:capi"
+task "clean_doc" => "doc:clean"
+task "clean_api_doc" => "doc:clean:api"
+task "clean_capi_doc" => "doc:clean:capi"
+task "view_api" => "doc:view:api"
+task "view_capi" => "doc:view:capi"

data/ext/enterprise_script_service/mruby/tasks/gitlab.rake

@@ -25,50 +25,49 @@ def run_cmd(cmd)
   raise 'error' unless system cmd
 end
 
-desc 'recreate docker images for GitLab builds'
-task :gitlab_dockers do
-  CI_COMPILERS.each do |compiler|
-    tag = ci_image_tag(compiler)
-    filename = "Dockerfile.#{tag}"
-    File.open(filename, 'wb') do |f|
-      f << "# #{compiler} - #{tag}\n"
-      f << "FROM #{CI_BASE}\n"
-      f << "RUN apt-get update && apt-get install -y git ruby2.3 ruby2.3-dev bison\n"
-      f << "RUN apt-get update && apt-get install -y binutils manpages\n"
-      f << "RUN apt-get update && apt-get install -y #{compiler}\n"
-      if compiler['gcc']
-        f << "RUN apt-get update && apt-get install -y libx32#{compiler}-dev\n"
-        f << "RUN apt-get update && apt-get install --no-install-recommends -y #{compiler}-multilib\n"
-      end
-      f << "RUN dpkg --add-architecture i386\n"
-      f << "RUN apt-get update && apt-get install -y linux-libc-dev:i386\n"
-      if compiler['clang']
-        f << "RUN apt-get update && apt-get install --no-install-recommends -y libc6-dev-i386\n"
-        f << "RUN apt-get update && apt-get install -y gcc gcc-multilib\n"
+namespace :gitlab do
+  desc 'recreate docker images for GitLab builds'
+  task :dockers do
+    CI_COMPILERS.each do |compiler|
+      tag = ci_image_tag(compiler)
+      filename = "Dockerfile.#{tag}"
+      File.open(filename, 'wb') do |f|
+        f << "# #{compiler} - #{tag}\n"
+        f << "FROM #{CI_BASE}\n"
+        f << "RUN apt-get update && apt-get install -y git ruby2.3 ruby2.3-dev bison\n"
+        f << "RUN apt-get update && apt-get install -y binutils manpages\n"
+        f << "RUN apt-get update && apt-get install -y #{compiler}\n"
+        if compiler['gcc']
+          f << "RUN apt-get update && apt-get install -y libx32#{compiler}-dev\n"
+          f << "RUN apt-get update && apt-get install --no-install-recommends -y #{compiler}-multilib\n"
+        end
+        f << "RUN dpkg --add-architecture i386\n"
+        f << "RUN apt-get update && apt-get install -y linux-libc-dev:i386\n"
+        if compiler['clang']
+          f << "RUN apt-get update && apt-get install --no-install-recommends -y libc6-dev-i386\n"
+          f << "RUN apt-get update && apt-get install -y gcc gcc-multilib\n"
+        end
       end
+      docker_tag = ci_docker_tag(compiler)
+      cmd1 = "docker build -t #{docker_tag} -f #{filename} ."
+      cmd2 = "docker push #{docker_tag}"
+      run_cmd cmd1
+      run_cmd cmd2
+      File.delete(filename)
     end
-    docker_tag = ci_docker_tag(compiler)
-    cmd1 = "docker build -t #{docker_tag} -f #{filename} ."
-    cmd2 = "docker push #{docker_tag}"
-    run_cmd cmd1
-    run_cmd cmd2
-    File.delete(filename)
   end
-end
 
-desc 'create build configurations and update .gitlab-ci.yml'
-task :gitlab_config do
-  require 'yaml'
+  desc 'create build configurations and update .gitlab-ci.yml'
+  task :config do
+    require 'yaml'
 
-  configs = []
-  [true, false].each do |mode_32|
-    ['', 'MRB_USE_FLOAT'].each do |float_conf|
-      ['', 'MRB_INT16', 'MRB_INT64'].each do |int_conf|
+    configs = []
+    [true, false].each do |mode_32|
+      ['', 'MRB_USE_FLOAT32'].each do |float_conf|
         ['', 'MRB_NAN_BOXING', 'MRB_WORD_BOXING'].each do |boxing_conf|
           ['', 'MRB_UTF8_STRING'].each do |utf8_conf|
-            next if (float_conf == 'MRB_USE_FLOAT') && (boxing_conf == 'MRB_NAN_BOXING')
+            next if (float_conf == 'MRB_USE_FLOAT32') && (boxing_conf == 'MRB_NAN_BOXING')
             next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_NAN_BOXING')
-            next if (int_conf == 'MRB_INT16') && (boxing_conf == 'MRB_WORD_BOXING')
             next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_WORD_BOXING') && mode_32
             env = [float_conf, int_conf, boxing_conf, utf8_conf].map do |conf|
               conf == '' ? nil : "-D#{conf}=1"
@@ -88,31 +87,35 @@ task :gitlab_config do
         end
       end
     end
-  end
-  path = './.gitlab-ci.yml'
-  data = YAML.load_file(path)
-  data.keys.select do |key|
-    key.start_with? 'Test'
-  end.each do |key|
-    data.delete(key)
-  end
-  CI_COMPILERS.each do |compiler|
-    configs.each do |config|
-      name = "Test #{compiler} #{config['_info']}"
-      hash = {
-        'CC' => compiler,
-        'CXX' => compiler.gsub('gcc', 'g++').gsub('clang', 'clang++'),
-        'LD' => compiler
-      }
-      hash = hash.merge(config)
-      hash.delete('_info')
-      data[name] = {
-        'stage' => 'test',
-        'image' => ci_docker_tag(compiler),
-        'variables' => hash,
-        'script' => 'env; rake --verbose all test'
-      }
+    path = './.gitlab-ci.yml'
+    data = YAML.load_file(path)
+    data.keys.select do |key|
+      key.start_with? 'Test'
+    end.each do |key|
+      data.delete(key)
+    end
+    CI_COMPILERS.each do |compiler|
+      configs.each do |config|
+        name = "Test #{compiler} #{config['_info']}"
+        hash = {
+          'CC' => compiler,
+          'CXX' => compiler.gsub('gcc', 'g++').gsub('clang', 'clang++'),
+          'LD' => compiler
+        }
+        hash = hash.merge(config)
+        hash.delete('_info')
+        data[name] = {
+          'stage' => 'test',
+          'image' => ci_docker_tag(compiler),
+          'variables' => hash,
+          'script' => 'env; rake --verbose all test'
+        }
+      end
     end
+    File.open(path, 'w') { |f| YAML.dump(data, f) }
   end
-  File.open(path, 'w') { |f| YAML.dump(data, f) }
 end
+
+# deprecated
+task "gitlab_config" => "gitlab:config"
+task "gitlab_dockers" => "gitlab:dockers"

data/ext/enterprise_script_service/mruby/tasks/libmruby.rake

@@ -1,4 +1,12 @@
 MRuby.each_target do
+  file libmruby_core_static => libmruby_core_objs.flatten do |t|
+    archiver.run t.name, t.prerequisites
+  end
+
+  products << libmruby_core_static
+
+  next unless libmruby_enabled?
+
   file libmruby_static => libmruby_objs.flatten do |t|
     archiver.run t.name, t.prerequisites
   end
@@ -21,5 +29,6 @@ MRuby.each_target do
       f.puts "MRUBY_LIBMRUBY_PATH = #{libmruby_static}"
     end
   end
-  task :all => "#{build_dir}/lib/libmruby.flags.mak"
+
+  products << libmruby_static
 end

data/ext/enterprise_script_service/mruby/tasks/mrbgems.rake

@@ -1,4 +1,6 @@
 MRuby.each_target do
+  active_gems_txt = "#{build_dir}/mrbgems/active_gems.txt"
+
   if enable_gems?
     # set up all gems
     gems.each(&:setup)
@@ -7,7 +9,7 @@ MRuby.each_target do
     # loader all gems
     self.libmruby_objs << 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, __FILE__] do |t|
+    file "#{build_dir}/mrbgems/gem_init.c" => [active_gems_txt, MRUBY_CONFIG, __FILE__] do |t|
       mkdir_p "#{build_dir}/mrbgems"
       open(t.name, 'w') do |f|
         gem_func_gems = gems.select { |g| g.generate_functions }
@@ -51,6 +53,16 @@ MRuby.each_target do
     end
   end
 
+  file active_gems_txt => :generate_active_gems_txt
+  task :generate_active_gems_txt do |t|
+    def t.timestamp; Time.at(0) end
+    active_gems = gems.sort_by(&:name).inject(""){|s, g| s << "#{g.name}\n"}
+    if !File.exist?(active_gems_txt) || File.read(active_gems_txt) != active_gems
+      mkdir_p File.dirname(active_gems_txt)
+      File.write(active_gems_txt, active_gems)
+    end
+  end
+
   # legal documents
   file "#{build_dir}/LEGAL" => [MRUBY_CONFIG, __FILE__] do |t|
     mkdir_p File.dirname t.name

data/ext/enterprise_script_service/mruby/tasks/mrblib.rake

@@ -0,0 +1,40 @@
+MRuby.each_target do
+  next unless libmruby_enabled?
+
+  src = "#{build_dir}/mrblib/mrblib.c"
+  rbfiles = Dir["#{MRUBY_ROOT}/mrblib/*.rb"].sort!
+
+  self.libmruby_objs << objfile(src.ext)
+
+  file src => [mrbcfile, __FILE__, *rbfiles] do |t|
+    if presym_enabled?
+      cdump = true
+      suffix = "proc"
+    else
+      cdump = false
+      suffix = "irep"
+    end
+    mkdir_p File.dirname(t.name)
+    File.open(t.name, 'w') do |f|
+      _pp "GEN", "mrblib/*.rb", "#{t.name.relative_path}"
+      f.puts %Q[/*]
+      f.puts %Q[ * This file is loading the mrblib]
+      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[ */]
+      unless presym_enabled?
+        f.puts %Q[#include <mruby.h>]
+        f.puts %Q[#include <mruby/irep.h>]
+      end
+      mrbc.run f, rbfiles, "mrblib_#{suffix}", cdump
+      f.puts %Q[void]
+      f.puts %Q[mrb_init_mrblib(mrb_state *mrb)]
+      f.puts %Q[{]
+      f.puts %Q[  mrblib_#{suffix}_init_syms(mrb);] if cdump
+      f.puts %Q[  mrb_load_#{suffix}(mrb, mrblib_#{suffix});]
+      f.puts %Q[}]
+    end
+  end
+end

data/ext/enterprise_script_service/mruby/tasks/presym.rake

@@ -0,0 +1,44 @@
+all_prerequisites = ->(task_name, prereqs) do
+  Rake::Task[task_name].prerequisites.each do |prereq_name|
+    next if prereqs[prereq_name]
+    prereqs[prereq_name] = true
+    all_prerequisites.(Rake::Task[prereq_name].name, prereqs)
+  end
+end
+
+MRuby.each_target do |build|
+  gensym_task = task(:gensym)
+  next unless build.presym_enabled?
+
+  presym = build.presym
+
+  include_dir = "#{build.build_dir}/include"
+  build.compilers.each{|c| c.include_paths << include_dir}
+  build.gems.each{|gem| gem.compilers.each{|c| c.include_paths << include_dir}}
+
+  prereqs = {}
+  pps = []
+  build_dir = "#{build.build_dir}/"
+  mrbc_build_dir = "#{build.mrbc_build.build_dir}/" if build.mrbc_build
+  build.products.each{|product| all_prerequisites.(product, prereqs)}
+  prereqs.each_key do |prereq|
+    next unless File.extname(prereq) == build.exts.object
+    next unless prereq.start_with?(build_dir)
+    next if mrbc_build_dir && prereq.start_with?(mrbc_build_dir)
+    pps << prereq.ext(build.exts.presym_preprocessed)
+  end
+
+  file presym.list_path => pps do
+    presyms = presym.scan(pps)
+    current_presyms = presym.read_list if File.exist?(presym.list_path)
+    update = presyms != current_presyms
+    presym.write_list(presyms) if update
+    mkdir_p presym.header_dir
+    %w[id table].each do |type|
+      next if !update && File.exist?(presym.send("#{type}_header_path"))
+      presym.send("write_#{type}_header", presyms)
+    end
+  end
+
+  gensym_task.enhance([presym.list_path])
+end

data/ext/enterprise_script_service/mruby/tasks/test.rake

@@ -0,0 +1,68 @@
+desc "build and run all mruby tests"
+task :test => "test:build" do
+  Rake::Task["test:run"].invoke
+end
+
+namespace :test do |test_ns|
+  desc "build and run library tests"
+  task :lib => "build:lib" do
+    test_ns["run:lib"].invoke
+  end
+
+  desc "build and run command binaries tests"
+  task :bin => :all do
+    test_ns["run:bin"].invoke
+  end
+
+  desc "build all mruby tests"
+  task :build => "build:lib"
+
+  namespace :build do |test_build_ns|
+    desc "build library tests"
+    task :lib => :all do
+      MRuby.each_target{|build| build.gem(core: 'mruby-test')}
+      test_build_ns["lib_without_loading_gem"].invoke
+    end
+  end
+
+  desc "run all mruby tests"
+  task :run
+
+  namespace :run do
+    desc "run library tests"
+    task :lib
+
+    desc "run command binaries tests"
+    task :bin
+  end
+end
+
+MRuby.each_target do |build|
+  if build.test_enabled?
+    t = task "test:build:lib_without_loading_gem:#{build.name}" do
+      gem = build.gems["mruby-test"]
+      gem.setup
+      gem.setup_compilers
+      Rake::Task[build.define_installer_if_needed("mrbtest")].invoke
+    end
+    task "test:build:lib_without_loading_gem" => t
+
+    t = task "test:run:lib:#{build.name}" do
+      build.run_test
+    end
+    task "test:run" => t
+    task "test:run:lib" => t
+  end
+  if build.bintest_enabled?
+    t = task "test:run:bin:#{build.name}" do
+      build.run_bintest
+    end
+    task "test:run" => t
+    task "test:run:bin" => t
+  end
+end
+
+task :clean do
+  host = MRuby.targets["host"]
+  rm_f host.exefile("#{host.class.install_dir}/mrbtest") if host && host.test_enabled?
+end

data/ext/enterprise_script_service/mruby/tasks/toolchains/android.rake

@@ -10,6 +10,7 @@ class MRuby::Toolchain::Android
     ~/Android/Sdk/ndk-bundle
     %LOCALAPPDATA%/Android/android-sdk/ndk-bundle
     %LOCALAPPDATA%/Android/android-ndk
+    %LOCALAPPDATA%/Android/Sdk/ndk/*
     ~/Library/Android/sdk/ndk-bundle
     ~/Library/Android/ndk
   }
@@ -40,6 +41,19 @@ Set ANDROID_PLATFORM environment variable or set :platform parameter
     end
   end
 
+  class SysrootNotReady < StandardError
+    def message
+      <<-EOM
+Couldn't find standard header files
+Please Move/Copy important file inside
+  <NDK_HOME>/sysroot/usr/include/
+to
+  <NDK_HOME>/platforms/<ANDROID_VERSION>/<ARCH>/usr/include/
+Higher NDK version will be use.
+      EOM
+    end
+  end
+
   attr_reader :params
 
   def initialize(params)
@@ -74,6 +88,25 @@ Set ANDROID_PLATFORM environment variable or set :platform parameter
         path.gsub! '%LOCALAPPDATA%', ENV['LOCALAPPDATA'] || '%LOCALAPPDATA%'
         path.gsub! '\\', '/'
         path.gsub! '~', Dir.home || '~'
+        path.gsub!('*') do
+          next nil unless path[-1] == "*"
+          dirs = Dir.glob(path).collect do |d|
+            m = d.match(/(\d+)\.(\d+)\.(\d+)$/)
+            m ? [m[1], m[2], m[3]].collect { |v| v.to_i } : nil
+          end
+          dirs.compact!
+          dirs.sort! do |before, after|
+            f = 0
+            if (f = (after.first <=> before.first)) != 0
+              next f
+            elsif (f = (after[1] <=> before[1])) != 0
+              next f
+            else
+              next after.last <=> before.last
+            end
+          end
+          dirs.empty? ? nil.to_s : dirs.first.join(".")
+        end
         File.directory?(path)
       } || raise(AndroidNDKHomeNotFound)
     )
@@ -146,7 +179,8 @@ Set ANDROID_PLATFORM environment variable or set :platform parameter
   end
 
   def sysroot
-    @sysroot ||= home_path.join('platforms', platform,
+    return @sysroot if @sysroot
+    sysroot_path = home_path.join('platforms', platform,
         case arch
         when /armeabi/    then 'arch-arm'
         when /arm64-v8a/  then 'arch-arm64'
@@ -156,6 +190,11 @@ Set ANDROID_PLATFORM environment variable or set :platform parameter
         when /mips/       then 'arch-mips'
         end
       ).to_s
+    if Dir.exist?(File.join(sysroot_path, "usr", "include"))
+      return @sysroot = sysroot_path
+    else
+      raise(SysrootNotReady)
+    end
   end
 
   def platform
@@ -259,6 +298,12 @@ Set ANDROID_PLATFORM environment variable or set :platform parameter
   def cflags
     flags = []
 
+    case RUBY_PLATFORM
+    when /mswin|mingw|win32/
+      # Build for Android dont need window flag
+      flags += %W(-U_WIN32 -U_WIN64)
+    end
+
     flags += %W(-MMD -MP -D__android__ -DANDROID --sysroot="#{sysroot}")
     flags += ctarget
     case toolchain

data/ext/enterprise_script_service/mruby/tasks/toolchains/gcc.rake

@@ -2,19 +2,21 @@ MRuby::Toolchain.new(:gcc) do |conf, params|
   default_command = params[:default_command] || 'gcc'
   compiler_flags = %w(-g -O3 -Wall -Wundef)
   c_mandatory_flags = %w(-std=gnu99)
-  cxx_invalid_flags = %w(-Wdeclaration-after-statement -Werror-implicit-function-declaration)
+  cxx_invalid_flags = %w(-Werror-implicit-function-declaration)
+  compile_opt = '%{flags} -o "%{outfile}" "%{infile}"'
 
   [conf.cc, conf.objc, conf.asm, conf.cxx].each do |compiler|
     if compiler == conf.cxx
-      compiler.command = ENV['CXX'] || default_command.sub(/cc|$/, '++')
+      compiler.command = ENV['CXX'] || conf.cc.command.sub(/g\Kcc|$/, '++')
       compiler.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || compiler_flags]
     else
       compiler.command = ENV['CC'] || default_command
       compiler.flags = [c_mandatory_flags, ENV['CFLAGS'] || [compiler_flags, cxx_invalid_flags, %w(-Wwrite-strings)]]
     end
-    compiler.option_include_path = '-I%s'
+    compiler.option_include_path = %q[-I"%s"]
     compiler.option_define = '-D%s'
-    compiler.compile_options = '%{flags} -MMD -o %{outfile} -c %{infile}'
+    compiler.compile_options = "-MMD -c #{compile_opt}"
+    compiler.preprocess_options = "-E -P #{compile_opt}"
     compiler.cxx_compile_flag = '-x c++ -std=gnu++03'
     compiler.cxx_exception_flag = '-fexceptions'
     compiler.cxx_invalid_flags = c_mandatory_flags + cxx_invalid_flags
@@ -27,7 +29,7 @@ MRuby::Toolchain.new(:gcc) do |conf, params|
     linker.library_paths = []
     linker.option_library = '-l%s'
     linker.option_library_path = '-L%s'
-    linker.link_options = '%{flags} -o %{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}'
+    linker.link_options = '%{flags} -o "%{outfile}" %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}'
   end
 
   [[conf.cc, 'c'], [conf.cxx, 'c++']].each do |cc, lang|
@@ -35,8 +37,7 @@ MRuby::Toolchain.new(:gcc) do |conf, params|
     def cc.header_search_paths
       if @header_search_command != command
         result = `echo | #{build.filename command} -x#{@header_search_language} -Wp,-v - -fsyntax-only 2>&1`
-        result = `echo | #{command} -x#{@header_search_language} -Wp,-v - -fsyntax-only 2>&1` if $?.exitstatus != 0
-        return include_paths if  $?.exitstatus != 0
+        return include_paths if $?.exitstatus != 0
 
         @frameworks = []
         @header_search_paths = result.lines.map { |v|