Merge branch 'backport-compiler-detection'

Author: ignisf

CHANGELOG.md

@@ -1,5 +1,6 @@
 ### Unreleased
 
+* Enhance compiler version detection and architecture detection #212
 * Introduce darwin13-15 binary building #211
 * Disable errors on warning for OS X #210
 * Improve --with-system-v8 error message #200

ext/libv8/builder.rb

@@ -102,7 +102,7 @@ def setup_build_deps!
     def choose_compiler
       compiler_names = if with_config('cxx') then [with_config('cxx')]
                        elsif ENV['CXX']      then [ENV['CXX']]
-                       else                       Compiler::KNOWN_COMPILERS
+                       else                       Compiler::well_known_compilers
                        end
 
       available_compilers = Compiler.available_compilers(*compiler_names)

ext/libv8/compiler.rb

@@ -1,42 +1,63 @@
-require 'mkmf'
-require 'open3'
+require 'rbconfig'
 require File.expand_path '../compiler/generic_compiler', __FILE__
 require File.expand_path '../compiler/gcc', __FILE__
 require File.expand_path '../compiler/clang', __FILE__
+require File.expand_path '../compiler/apple_llvm', __FILE__
 
 module Libv8
   module Compiler
-    KNOWN_COMPILERS = [
-                       'c++',
-                       'g++48', 'g++46', 'g++44', 'g++',
-                       'clang++',
-                      ]
-
     module_function
 
-    def system_compilers
-      available_compilers *Compiler::KNOWN_COMPILERS
+    def well_known_compilers
+      compilers = []
+
+      # The default system compiler
+      compilers << 'c++'
+
+      # FreeBSD GCC command names
+      compilers += ['g++48', 'g++49', 'g++5', 'g++6', 'g++7']
+
+      # Default compiler names
+      compilers += ['clang++', 'g++']
+
+      compilers.uniq
     end
 
     def available_compilers(*compiler_names)
-      compiler_paths = compiler_names.map { |name| find name }.reject &:nil?
+      available = compiler_names.select { |compiler_name| available? compiler_name }
+      available.map { |compiler_name| type_of(compiler_name).new compiler_name }
     end
 
-    def find(name)
-      return nil if name.empty?
-      path, _, status = Open3.capture3 "which #{name}"
-      path.chomp!
-      determine_type(path).new(path) if status.success?
+    def type_of(compiler_name)
+      case version_string_of(compiler_name)
+      when /^Apple LLVM\b/ then AppleLLVM
+      when /\bclang\b/i then Clang
+      when /^gcc/i then GCC
+      else GenericCompiler
+      end
     end
 
-    def determine_type(compiler_path)
-      compiler_version = Open3.capture3("#{compiler_path} -v")[0..1].join
+    def version_string_of(compiler_name)
+      command_result = execute_command "#{compiler_name} -v 2>&1"
 
-      case compiler_version
-      when /\bclang\b/i then Clang
-      when /^gcc/i      then GCC
-      else                   GenericCompiler
+      unless command_result.status.success?
+        raise "Could not get version string of compiler #{compiler_name}"
       end
+
+      command_result.output
+    end
+
+    def available?(command)
+      execute_command("which #{command} 2>&1").status.success?
+    end
+
+    def execute_command(command)
+      output = `env LC_ALL=C LANG=C #{command}`
+      status = $?
+      ExecutionResult.new output, status
+    end
+
+    class ExecutionResult < Struct.new(:output, :status)
     end
   end
 end

ext/libv8/compiler/apple_llvm.rb

@@ -0,0 +1,21 @@
+module Libv8
+  module Compiler
+    class AppleLLVM < Clang
+      LLVM_VERSION_REGEXP = /Apple LLVM version (\d+\.\d+(\.\d+)*) \(/i
+
+      def name
+        'Apple LLVM'
+      end
+
+      def compatible?
+        version >= '4.3' unless version.nil?
+      end
+
+      private
+
+      def version_regexp
+        LLVM_VERSION_REGEXP
+      end
+    end
+  end
+end

ext/libv8/compiler/clang.rb

@@ -1,14 +1,20 @@
 module Libv8
   module Compiler
     class Clang < GenericCompiler
-      VERSION_REGEXP = /clang version (\d+\.\d+(\.\d+)*) \(/i
+      CLANG_VERSION_REGEXP = /clang version (\d+\.\d+(\.\d+)*) \(/i
 
       def name
         'clang'
       end
 
       def compatible?
-        version >= '3.1'
+        version >= '3.1' unless version.nil?
+      end
+
+      private
+
+      def version_regexp
+        CLANG_VERSION_REGEXP
       end
     end
   end

ext/libv8/compiler/gcc.rb

@@ -1,14 +1,20 @@
 module Libv8
   module Compiler
     class GCC < GenericCompiler
-      VERSION_REGEXP = /gcc version (\d+\.\d+(\.\d+)*)/i
+      GCC_VERSION_REGEXP = /gcc version (\d+\.\d+(\.\d+)*)/i
 
       def name
         'GCC'
       end
 
       def compatible?
-        version > '4.3' and version < '5'
+        version > '4.3' unless version.nil?
+      end
+
+      private
+
+      def version_regexp
+        GCC_VERSION_REGEXP
       end
     end
   end

ext/libv8/compiler/generic_compiler.rb

@@ -1,28 +1,28 @@
 module Libv8
   module Compiler
     class GenericCompiler
-      VERSION_REGEXP = /(\d+\.\d+(\.\d+)*)/
-      TARGET_REGEXP = /Target: ([a-z0-9\-_.]*)/
+      GENERIC_VERSION_REGEXP = /(\d+\.\d+(\.\d+)*)/
+      GENERIC_TARGET_REGEXP = /Target: ([a-z0-9\-_.]*)/
 
-      def initialize(path)
-        @path = path
+      def initialize(command)
+        @command = command
       end
 
       def name
-        File.basename @path
+        File.basename @command
       end
 
       def to_s
-        @path
+        @command
       end
 
       def version
-        call('-v')[0..1].join =~ VERSION_REGEXP
+        version_string =~ version_regexp
         $1
       end
 
       def target
-        call('-v')[0..1].join =~ TARGET_REGEXP
+        version_string =~ target_regexp
         $1
       end
 
@@ -31,7 +31,25 @@ def compatible?
       end
 
       def call(*arguments)
-        Open3.capture3 arguments.unshift('env LC_ALL=en', @path).join(' ')
+        Compiler::execute_command arguments.unshift(@command).join(' ')
+      end
+
+      private
+
+      def version_string
+        begin
+          Compiler::version_string_of @command
+        rescue StandardError
+          nil
+        end
+      end
+
+      def version_regexp
+        GENERIC_VERSION_REGEXP
+      end
+
+      def target_regexp
+        GENERIC_TARGET_REGEXP
       end
     end
   end