metacc 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb94d9b47a11ec5a78ea57ae19417e6423287918287f675e43579af8015e4c63
-  data.tar.gz: b1237b3e41f2ae7ae68066441d742892ca77fd0427dc3e7b8f02b7f92049e535
+  metadata.gz: d68166f1cf0263814b009c61e2b615ee36521656734bb4ef0b0e48677751fafa
+  data.tar.gz: 12133182cb6f8b899714eb7fdbc95868ecdbfd40fe80bbe43084ed79d0fa5e88
 SHA512:
-  metadata.gz: 4774d4160c9939259634b2625b28a2975360c477c56c53ac689b4208defb698c4fbcbccf829f540583dfb94cf801fc62664e94cc900f52c64c28bfd6f763247c
-  data.tar.gz: dfd5493d3789ea3f18dbd1d7a6a15c345fe6eaeb262e022af7a79039bdd7b2707416312fc08e1ca86b333d91520dbb41457f6be5006d30157af934d4fe8b1497
+  metadata.gz: d3257e9318b06bfdc812d3a344dc3bece65e22199e4bbc68f3c5f9867593d8b1c4fa8e9376078abf0a056d75f6fa4a8782716152d50f24e6c0a314632f27d3d1
+  data.tar.gz: c413d78b53e7a7486a895e1595ec064173cca98235cd35ae595dcd31af9f95b4c526ce8c47b452b53955615ba0166e341a3b9e071508d457580479ca4397fb1f

data/lib/metacc/cli.rb

@@ -12,28 +12,28 @@ module MetaCC
   class CLI
 
     WARNING_CONFIGS = {
-      "all" =>   :warn_all,
+      "all"   => :warn_all,
       "error" => :warn_error
     }
 
     SANITIZERS = {
-      nil =>      :sanitize_default,
+      nil      => :sanitize_default,
       "memory" => :sanitize_memory,
-      "thread" => :sanitize_thread,
+      "thread" => :sanitize_thread
     }
 
     TARGETS = {
       "sse4.2" => :sse4_2,
-      "avx" =>    :avx,
-      "avx2" =>   :avx2,
+      "avx"    => :avx,
+      "avx2"   => :avx2,
       "avx512" => :avx512,
       "native" => :native
     }.freeze
 
     STANDARDS = {
-      "c11" =>   :c11,
-      "c17" =>   :c17,
-      "c23" =>   :c23,
+      "c11"   => :c11,
+      "c17"   => :c17,
+      "c23"   => :c23,
       "c++11" => :cxx11,
       "c++14" => :cxx14,
       "c++17" => :cxx17,
@@ -44,11 +44,11 @@ module MetaCC
 
     # Maps --x<name> CLI option names to xflags toolchain-class keys.
     XFLAGS = {
-      "xmsvc" => MSVC,
-      "xgnu" => GNU,
-      "xclang" => Clang,
+      "xmsvc"    => MSVC,
+      "xgnu"     => GNU,
+      "xclang"   => Clang,
       "xclangcl" => ClangCL,
-      "xtinycc" => TinyCC
+      "xtinycc"  => TinyCC
     }.freeze
 
     def initialize(driver: Driver.new)
@@ -128,7 +128,7 @@ module MetaCC
         "Enable sanitizer(s)",
         "  --sanitize        => address, undefined, leak",
         "  --sanitize=memory => memory",
-        "  --sanitize=thread => thread",
+        "  --sanitize=thread => thread"
       ) do |value|
         options[:flags] << SANITIZERS[value]
       end
@@ -142,10 +142,10 @@ module MetaCC
       parser.on("--lto", "Enable link time optimization") do
         options[:flags] << :lto
       end
-      parser.on("--omit-frame-pointer") do |value|
+      parser.on("--omit-frame-pointer") do
         options[:flags] << :omit_frame_pointer
       end
-      parser.on("--strict-aliasing") do |value|
+      parser.on("--strict-aliasing") do
         options[:flags] << :strict_aliasing
       end
 
@@ -155,13 +155,13 @@ module MetaCC
       parser.on("-m", "--arch=ARCH", "Target architecture") do |value|
         options[:flags] << TARGETS[value]
       end
-      parser.on("--pic", "Generate position independent code") do |value|
+      parser.on("--pic", "Generate position independent code") do
         options[:flags] << :pic
       end
-      parser.on("--no-rtti", "Disable runtime type information") do |value|
+      parser.on("--no-rtti", "Disable runtime type information") do
         options[:flags] << :no_rtti
       end
-      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do |value|
+      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do
         options[:flags] << :no_exceptions
       end
 
@@ -171,10 +171,10 @@ module MetaCC
       parser.on("--static", "Produce a static library") do
         options[:flags] << :static
       end
-      parser.on("--shared", "Produce a shared library") do |value|
+      parser.on("--shared", "Produce a shared library") do
         options[:flags] << :shared
       end
-      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do |value|
+      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do
         options[:flags] << :shared_compat
       end
       parser.on("-c", "Compile only (produce object files without linking)") do
@@ -216,23 +216,28 @@ module MetaCC
 
     def validate_options!(flags, output_path, link:, run:)
       if !link && output_path
-        raise OptionParser::InvalidOption, "cannot specify output path (-o) in compile only mode (-c)"
+        raise OptionParser::InvalidOption,
+              "cannot specify output path (-o) in compile only mode (-c)"
       end
 
       if link && !output_path
-        raise OptionParser::InvalidOption, "must specify an output path (-o)"
+        raise OptionParser::InvalidOption,
+              "must specify an output path (-o)"
       end
 
       if run && (!link || %i[static shared shared_compat].any? { |f| flags.include?(f) })
-        raise OptionParser::InvalidOption, "--run cannot be used with -c, --static, --shared, or --shared-compat"
+        raise OptionParser::InvalidOption,
+              "--run cannot be used with -c, --static, --shared, or --shared-compat"
       end
 
       if !link && %i[static shared shared_compat].any? { |f| flags.include?(f) }
-        raise OptionParser::InvalidOption, "compile only mode (-c) cannot be used with --static, --shared, or --shared-compat"
+        raise OptionParser::InvalidOption,
+              "compile only mode (-c) cannot be used with --static, --shared, or --shared-compat"
       end
 
       if flags.include?(:debug_info) && flags.include?(:strip)
-        raise OptionParser::InvalidOption, "--debug-info (-g) cannot be combined with --strip (-s)"
+        raise OptionParser::InvalidOption,
+              "--debug-info (-g) cannot be combined with --strip (-s)"
       end
     end
 
@@ -246,9 +251,9 @@ module MetaCC
         options.delete(:libs)
         result = @driver.compile(input_paths, **options)
       end
-      if options[:dry_run]
-        puts result.map { |cmd| cmd.join(" ") }
-      end
+      return unless options[:dry_run]
+
+      puts(result.map { |cmd| cmd.join(" ") })
     end
 
   end

data/lib/metacc/driver.rb

@@ -21,18 +21,23 @@ module MetaCC
     DBG_SANITIZE_FLAGS = Set.new(%i[sanitize_default sanitize_memory sanitize_thread]).freeze
 
     ALL_FLAGS = Set.new([
-      *%i[
-        warn_all warn_error
-        debug_info
-        omit_frame_pointer strict_aliasing
-        no_rtti no_exceptions
-        pic shared shared_compat static strip
-      ],
-      *LANGUAGE_STD_FLAGS,
-      *ARCHITECTURE_FLAGS,
-      *OPTIMIZATION_FLAGS,
-      *DBG_SANITIZE_FLAGS
-    ]).freeze
+                          :warn_all,
+                          :warn_error,
+                          :debug_info,
+                          :omit_frame_pointer,
+                          :strict_aliasing,
+                          :no_rtti,
+                          :no_exceptions,
+                          :pic,
+                          :shared,
+                          :shared_compat,
+                          :static,
+                          :strip,
+                          *LANGUAGE_STD_FLAGS,
+                          *ARCHITECTURE_FLAGS,
+                          *OPTIMIZATION_FLAGS,
+                          *DBG_SANITIZE_FLAGS
+                        ]).freeze
 
     # The detected toolchain (a Toolchain subclass instance).
     attr_reader :toolchain
@@ -62,13 +67,13 @@ module MetaCC
     # @raise [CompileError] if the underlying toolchain executable returns a non-zero exit status
     def compile(
       input_files,
-      flags: [],
-      xflags: {},
+      flags:         [],
+      xflags:        {},
       include_paths: [],
-      defs: [],
-      env: {},
-      working_dir: ".",
-      dry_run: false
+      defs:          [],
+      env:           {},
+      working_dir:   ".",
+      dry_run:       false
     )
       flags = translate_flags(flags)
       flags.concat(xflags[@toolchain.class] || [])
@@ -105,18 +110,18 @@ module MetaCC
     def compile_and_link(
       input_files,
       output_path,
-      flags: [],
-      xflags: {},
+      flags:         [],
+      xflags:        {},
       include_paths: [],
-      defs: [],
-      link_paths: [],
-      libs: [],
-      env: {},
-      working_dir: ".",
-      dry_run: false
+      defs:          [],
+      link_paths:    [],
+      libs:          [],
+      env:           {},
+      working_dir:   ".",
+      dry_run:       false
     )
-      output_type = if flags.include?(:shared)  then :shared
-                    elsif flags.include?(:static)  then :static
+      output_type = if flags.include?(:shared) then :shared
+                    elsif flags.include?(:static) then :static
                     else :executable
                     end
       output_path = apply_default_extension(output_path, output_type)

data/lib/metacc/platform.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module MetaCC
+
+  module Platform
+
+    def self.windows?
+      @windows ||= RbConfig::CONFIG["host_os"].match?(/mswin|mingw32|windows/)
+    end
+
+    def self.cygwin?
+      @cygwin ||= RbConfig::CONFIG["host_os"].match?(/cygwin/)
+    end
+
+    def self.apple?
+      @apple ||= RbConfig::CONFIG["host_os"].match?(/darwin/)
+    end
+
+    def self.executable_ext
+      if windows? || cygwin?
+        ".exe"
+      elsif apple?
+        ".dylib"
+      else
+        ""
+      end
+    end
+
+    def self.executable_ext
+      windows? || cygwin? ? ".exe" : ""
+    end
+
+    def self.shared_library_ext
+      if windows? || cygwin?
+        ".dll"
+      elsif apple?
+        ".dylib"
+      else
+        ".so"
+      end
+    end
+
+  end
+
+end

data/lib/metacc/toolchain.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "rbconfig"
 require "tempfile"
+require_relative "platform"
 
 module MetaCC
 
@@ -78,7 +78,7 @@ module MetaCC
     # The output mode (object files, shared library, static library, or
     # executable) is determined by the translated flags.
     def compile_command(
-      input_files,
+      _input_files,
       flags:,
       include_paths:,
       defs:
@@ -87,8 +87,8 @@ module MetaCC
     end
 
     def compile_and_link_commands(
-      input_files,
-      output_file,
+      _input_files,
+      _output_file,
       flags:,
       include_paths:,
       defs:,
@@ -105,20 +105,11 @@ module MetaCC
     # @param output_type [:objects, :shared, :static, :executable]
     # @return [String]
     def default_extension(output_type)
-      host_os = RbConfig::CONFIG["host_os"]
       case output_type
       when :objects    then ".o"
-      when :static     then ".a"
-      when :shared
-        if host_os.match?(/mswin|mingw|cygwin/)
-          ".dll"
-        elsif host_os.match?(/darwin/)
-          ".dylib"
-        else
-          ".so"
-        end
-      when :executable
-        host_os.match?(/mswin|mingw|cygwin/) ? ".exe" : ""
+      when :static     then ".a" # MingGW uses .a, not .lib
+      when :shared     then MetaCC::Platform.shared_library_ext
+      when :executable then MetaCC::Platform.executable_ext
       else
         raise ArgumentError, "unknown output_type: #{output_type.inspect}"
       end
@@ -178,6 +169,30 @@ module MetaCC
       [[c, *flags, *inc_flags, *def_flags, *input_files, *lib_path_flags, *lib_flags, "-o", output_file]]
     end
 
+    def self.platform_flags
+      if MetaCC::Platform.windows?
+        {
+          # MingGW doesn't have full UBsan support, but it can trap on detected errors.
+          # It does not support the address or leak sanitizers.
+          sanitize_default: ["-fsanitize=undefined", "-fsanitize-undefined-trap-on-error"],
+          # MingGW doesn't support the thread sanitizer
+          sanitize_thread: []
+        }
+      elsif MetaCC::Platform.apple?
+        # gcc's support for sanitizers on OSX/iOS is *very* spotty.
+        # So we disable everything.
+        {
+          sanitize_default: [],
+          sanitize_thread: []
+        }
+      else
+        # Otherwise assume Linux/BSD and keep the default
+        {}
+      end
+    end
+
+    private_class_method :platform_flags
+
     GNU_FLAGS = {
       o0:                    ["-O0"],
       o1:                    ["-O1"],
@@ -217,7 +232,7 @@ module MetaCC
       static:                ["-static"],
       strip:                 ["-Wl,--strip-unneeded"],
       debug:                 ["-D_GLIBCXX_DEBUG", "-fasynchronous-unwind-tables"]
-    }.freeze
+    }.merge(platform_flags).freeze
 
   end
 
@@ -240,10 +255,26 @@ module MetaCC
       super("clang", search_paths:)
     end
 
+    def self.platform_flags
+      if MetaCC::Platform.windows?
+        {
+          # The leak sanitizer is not supported on Windows
+          sanitize_default: ["-fsanitize=address,undefined"],
+          # The thread sanitizer is not supported on Windows
+          sanitize_thread:  []
+        }
+      else
+        # For all other platforms, stick with the defaults
+        {}
+      end
+    end
+
+    private_class_method :platform_flags
+
     CLANG_FLAGS = GNU_FLAGS.merge(
-      lto: ["-flto=thin"],
-      sanitize_memory: ["-fsanitize=memory"]
-    ).freeze
+                    lto: ["-flto=thin"],
+                    sanitize_memory: ["-fsanitize=memory"] 
+                  ).merge(platform_flags)
 
     def flags
       CLANG_FLAGS
@@ -324,7 +355,7 @@ module MetaCC
       sanitize_memory:       [],
       sanitize_thread:       [],
       no_rtti:               ["/GR-"],
-      no_exceptions:         ["/EHs-", "/EHc-"],
+      no_exceptions:         ["/EHs-", "/EHc-", "/D_HAS_EXCEPTIONS=0"],
       pic:                   [],
       omit_frame_pointer:    ["/Oy"],
       no_omit_frame_pointer: ["/Oy-"],
@@ -402,7 +433,7 @@ module MetaCC
     #
     # Parses the output of `vcvarsall.bat … && set` and merges the resulting
     # environment variables into the current process's ENV.
-    def MSVC.vcvarsall(devenv_path)
+    def self.vcvarsall(devenv_path)
       # See https://stackoverflow.com/a/19929778
       return if ENV.key?("DevEnvDir")
 
@@ -418,7 +449,7 @@ module MetaCC
       Tempfile.create(["vcvarsall", ".bat"]) do |file|
         # Write a stub batch file that run vcvarsall.bat and dumps the
         # environment to stdout
-        file.puts %Q{"#{vcvarsall.gsub('"', '""')}" x64 && set}
+        file.puts %("#{vcvarsall.gsub('"', '""')}" x64 && set)
         file.flush
 
         # Run the stub batch file
@@ -470,7 +501,7 @@ module MetaCC
     end
 
     def compile_and_link_commands(input_files, output_file, **options)
-      commands = super(input_files, output_file, **options)
+      commands = super
       if options[:flags].include?(:static)
         object_files = input_files.map { |f| f.sub(/\.c\z/, ".o") }
         commands << [@ar, "rcs", output_file, *object_files]
@@ -533,7 +564,4 @@ module MetaCC
 
   end
 
-  class AutoToolchain
-  end
-
 end

data/lib/metacc/version.rb

@@ -2,6 +2,6 @@
 
 module MetaCC
 
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 
 end

data/lib/metacc.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
-require "metacc/driver"
 require "metacc/version"
+require "metacc/platform"
+require "metacc/toolchain"
+require "metacc/driver"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metacc
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Praneeth Sadda
@@ -22,6 +22,7 @@ files:
 - lib/metacc.rb
 - lib/metacc/cli.rb
 - lib/metacc/driver.rb
+- lib/metacc/platform.rb
 - lib/metacc/toolchain.rb
 - lib/metacc/version.rb
 homepage: https://github.com/psadda/metacc
@@ -38,7 +39,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="