metacc 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f277277e6c19c84a200cf69d21452da422980b3955c895bc148666b2e170d7c
-  data.tar.gz: e17a0627af2e670202be743c4e745a6aedaf10284ead45cd7c6740dd64dcf4b0
+  metadata.gz: a14fc8ca9c502275a4cc8105906722c167fb58cf6a269559748da22cf88f83d3
+  data.tar.gz: f56a289ba4240caf683f8614f5317252753032ad8902cce314a0ab43380d05fd
 SHA512:
-  metadata.gz: d889eff550e1f704c4e4264d750c1d03ddd7e040c1303eb6147501de5b0b2eec970c595cf183afe6fe7da91ee9465c0aa70f7596887018d3b9f4e979801e9f27
-  data.tar.gz: 9a0ae1d9c54d117d809dc236396ee0d4a69b321161a535287195474cdd6845a78dc0352bfe0b51f80487dbe25d9194a2afb98320ed2c90ff458f857d2be92f53
+  metadata.gz: 2b5c6055a1445b3e0341fbde3da0ca9b76e2cfe021c0c7694be91233a2eb2c68de7f063cc5c2b9b953b697fdfa41f3a949b168eb33790d8544fedeeef90f222a
+  data.tar.gz: 30b826250c85ce5d7b57c83f81714d7ac51b6e911abed4ea8371e3bc36540f0b29779aeced94b398b7d590ffbbbf608c7ab2929f0d9743a8967824edad8bea59

data/bin/metacc

@@ -5,4 +5,10 @@ $LOAD_PATH.unshift(File.join(__dir__, "..", "lib"))
 
 require "metacc/cli"
 
-MetaCC::CLI.new.run(ARGV)
+begin
+  MetaCC::CLI.new.run(ARGV)
+rescue MetaCC::CLI::InvalidOption, MetaCC::ToolchainNotFoundError => e
+  warn "#{$0} error: #{e.message}"
+rescue MetaCC::CompileError => e
+  warn e.message
+end

data/lib/metacc/cli.rb

@@ -16,7 +16,7 @@ module MetaCC
   #   --std=c++11 --std=c++14 --std=c++17 --std=c++20 --std=c++23 --std=c++26
   #
   # Linking:
-  #   --objects / -c     – compile only; don't link
+  #   -c                 – compile only; don't link
   #   -l, -L             - specify linker input
   #   --shared           – produce a shared library
   #   --static           – produce a static library
@@ -69,9 +69,9 @@ module MetaCC
     }.freeze
 
     STANDARDS = {
-      "c11"   => :c11,
-      "c17"   => :c17,
-      "c23"   => :c23,
+      "c11" =>   :c11,
+      "c17" =>   :c17,
+      "c23" =>   :c23,
       "c++11" => :cxx11,
       "c++14" => :cxx14,
       "c++17" => :cxx17,
@@ -82,42 +82,46 @@ 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
     }.freeze
 
-    def run(argv, driver: Driver.new)
-      options, input_paths = parse_compile_args(argv, driver:)
+    def initialize(driver: Driver.new)
+      @driver = driver
+    end
+
+    def run(argv)
+      input_paths, options = parse_compile_args(argv)
       output_path = options.delete(:output_path)
-      run_flag = options.delete(:run)
-      validate_options!(options[:flags], output_path, run_flag)
-      invoke(driver, input_paths, output_path, options, run: run_flag)
+      validate_options!(options[:flags], output_path, link: options[:link], run: options[:run])
+      invoke(input_paths, output_path, **options)
     end
 
     # Parses compile arguments.
-    # Returns [options_hash, remaining_positional_args].
-    def parse_compile_args(argv, driver: nil)
+    # Returns [positional_args, options_hash].
+    def parse_compile_args(argv)
       options = {
         include_paths: [],
-        defs: [],
-        linker_paths: [],
-        libs: [],
-        output_path: nil,
-        run: false,
-        flags: [],
-        xflags: {},
+        defs:          [],
+        link:          true,
+        link_paths:    [],
+        libs:          [],
+        output_path:   nil,
+        run:           false,
+        flags:         [],
+        xflags:        {}
       }
       parser = OptionParser.new
-      setup_compile_options(parser, options, driver:)
-      sources = parser.permute(argv)
-      [options, sources]
+      setup_compile_options(parser, options)
+      input_paths = parser.permute(argv)
+      [input_paths, options]
     end
 
     private
 
-    def setup_compile_options(parser, options, driver: nil)
+    def setup_compile_options(parser, options)
       parser.on("-o FILEPATH", "Output file path") do |value|
         options[:output_path] = value
       end
@@ -127,26 +131,23 @@ module MetaCC
       parser.on("-D DEF", "Add a preprocessor definition") do |value|
         options[:defs] << value
       end
-      parser.on("-O LEVEL", /\A[0-3]\z/, "Optimization level (0–3)") do |level|
-        options[:flags] << :"o#{l}"
-      end
-      parser.on("-Os", "Optimize for size") do
-        options[:flags] << :os
+      parser.on("-O LEVEL", /\A[0-3]|s\z/, "Optimization level (0–3)") do |level|
+        options[:flags] << :"o#{level}"
       end
       parser.on("-m", "--arch ARCH", "Target architecture") do |value|
-        options[:flags] << TARGETS[v]
+        options[:flags] << TARGETS[value]
       end
       parser.on("-g", "--debug", "Emit debugging symbols") do
         options[:flags] << :debug
       end
       parser.on("--std STANDARD", "Specify the language standard") do |value|
-        options[:flags] << STANDARDS[v]
+        options[:flags] << STANDARDS[value]
       end
       parser.on("-W OPTION", "Configure warnings") do |value|
-        options[:flags] << WARNING_CONFIGS[v]
+        options[:flags] << WARNING_CONFIGS[value]
       end
-      parser.on("-c", "--objects", "Produce object files") do
-        options[:flags] << :objects
+      parser.on("-c", "Produce object files") do
+        options[:link] = false
       end
       parser.on("-r", "--run", "Run the compiled executable after a successful build") do
         options[:run] = true
@@ -155,7 +156,7 @@ module MetaCC
         options[:libs] << value
       end
       parser.on("-L DIR", "Add linker library search path") do |value|
-        options[:linker_paths] << value
+        options[:link_paths] << value
       end
       parser.on("--shared", "Produce a shared library") do
         options[:flags] << :shared
@@ -178,39 +179,37 @@ module MetaCC
         end
       end
       parser.on_tail("--version", "Print the toolchain version and exit") do
-        puts driver&.toolchain&.version_banner
+        puts @driver.toolchain.version_banner
         exit
       end
     end
 
-    def validate_options!(flags, output_path, run_flag)
-      objects = flags.include?(:objects)
-
-      if objects && output_path
-        warn "error: -o cannot be used with --objects"
-        exit 1
+    def validate_options!(flags, output_path, link:, run:)
+      if !link && output_path
+        raise InvalidOption, "cannot specify output path (-o) in compile only mode (-c)"
       end
 
-      unless objects || output_path
-        warn "error: -o is required"
-        exit 1
+      if link && !output_path
+        raise InvalidOption, "must specify an output path (-o)"
       end
 
-      if run_flag && (objects || flags.include?(:shared) || flags.include?(:static))
-        warn "error: --run cannot be used with --objects, --shared, or --static"
-        exit 1
+      if run && (!link || flags.include?(:shared) || flags.include?(:static))
+        raise InvalidOption, "--run may not be used with -c, --shared, or --static"
       end
     end
 
-    def run_executable(path)
-      system(path)
+    def invoke(input_paths, desired_output_path = nil, link: true, run: false, **options)
+      if link
+        actual_output_path = @driver.compile_and_link(input_paths, desired_output_path, **options)
+        system(actual_output_path) if run
+      else
+        options.delete(:link_paths)
+        options.delete(:libs)
+        @driver.compile(input_paths, **options)
+      end
     end
 
-    def invoke(driver, input_paths, output_path, options, run: false)
-      result = driver.invoke(input_paths, output_path, **options)
-      exit 1 unless result
-      run_executable(result) if run
-    end
+    class InvalidOption < StandardError; end
 
   end
 

data/lib/metacc/driver.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require "open3"
 require_relative "toolchain"
 
 module MetaCC
 
   # Raised when no supported C/C++ compiler can be found on the system.
-  class CompilerNotFoundError < StandardError; end
+  class CompileError < StandardError; end
+
+  # Raised when no supported C/C++ compiler can be found on the system.
+  class ToolchainNotFoundError < StandardError; end
 
   # Driver wraps C and C++ compile and link operations using the first
   # available compiler found on the system (Clang, GCC, or MSVC).
@@ -22,7 +26,7 @@ module MetaCC
         asan ubsan msan
         no_rtti no_exceptions pic
         no_semantic_interposition no_omit_frame_pointer no_strict_aliasing
-        objects shared static strip
+        shared static strip
       ]
     ).freeze
 
@@ -36,16 +40,48 @@ module MetaCC
     #                                   Defaults to [Clang, GNU, MSVC].
     # @param search_paths [Array<String>] directories to search for toolchain executables
     #                                    before falling back to PATH. Defaults to [].
-    # @raise [CompilerNotFoundError] if no supported compiler is found.
-    def initialize(prefer: [Clang, GNU, MSVC],
-                   search_paths: [])
+    # @raise [ToolchainNotFoundError] if no supported compiler is found.
+    def initialize(prefer: [MSVC], search_paths: [])
       @toolchain = select_toolchain!(prefer, search_paths)
     end
 
+    # Invokes the compiler driver for the given input files and output path,
+    # compiling and producting object files without linking.
+    #
+    # @param input_files    [String, Array<String>] paths to the input files
+    # @param flags          [Array<Symbol>] compiler/linker flags
+    # @param xflags         [Hash{Class => String}] extra (native) compiler flags keyed by toolchain Class
+    # @param include_paths  [Array<String>] directories to add with -I
+    # @param defs           [Array<String>] preprocessor macros (e.g. "FOO" or "FOO=1")
+    # @param env            [Hash] environment variables to set for the subprocess
+    # @param working_dir    [String] working directory for the subprocess (default: ".")
+    # @raise [CompileError] if the underlying toolchain executable returns a non-zero exit status
+    def compile(
+      input_files,
+      flags: [],
+      xflags: {},
+      include_paths: [],
+      defs: [],
+      env: {},
+      working_dir: "."
+    )
+      flags = translate_flags(flags)
+      flags.concat(xflags[@toolchain.class] || [])
+
+      cmd = @toolchain.compile_command(
+        input_files,
+        flags:,
+        include_paths:,
+        defs:
+      )
+
+      !!run_command(cmd, env:, working_dir:)
+    end
+
     # Invokes the compiler driver for the given input files and output path.
     # The kind of output (object files, executable, shared library, or static
-    # library) is determined by the flags: +:objects+, +:shared+, or +:static+.
-    # When none of these mode flags is present, an executable is produced.
+    # library) is determined by the flags: +:shared+ or +:static+. When none of
+    # these mode flags is present, an executable is produced.
     #
     # @param input_files    [String, Array<String>] paths to the input files
     # @param output_path    [String] path for the resulting output file
@@ -53,37 +89,45 @@ module MetaCC
     # @param xflags         [Hash{Class => String}] extra (native) compiler flags keyed by toolchain Class
     # @param include_paths  [Array<String>] directories to add with -I
     # @param defs           [Array<String>] preprocessor macros (e.g. "FOO" or "FOO=1")
-    # @param libs           [Array<String>] library names to link (e.g. "m", "pthread")
     # @param linker_paths   [Array<String>] linker library search paths (-L / /LIBPATH:)
+    # @param libs           [Array<String>] library names to link (e.g. "m", "pthread")
     # @param env            [Hash] environment variables to set for the subprocess
     # @param working_dir    [String] working directory for the subprocess (default: ".")
-    # @return [String, true, nil] the (possibly extension-augmented) output path on success,
-    #   true if output_path was nil and the command succeeded,
-    #   nil if the underlying toolchain executable returned a non-zero exit status
-    # @raise [ArgumentError] if output_path is nil and the :objects flag is not present
-    def invoke(
+    # @return [String] the (possibly extension-augmented) output path on success
+    # @raise [CompileError] if the underlying toolchain executable returns a non-zero exit status
+    def compile_and_link(
       input_files,
       output_path,
       flags: [],
       xflags: {},
       include_paths: [],
       defs: [],
+      link_paths: [],
       libs: [],
-      linker_paths: [],
       env: {},
       working_dir: "."
     )
-      output_type = output_type_from_flags(flags)
-      raise ArgumentError, "output_path must not be nil" if output_path.nil? && output_type != :objects
-
-      output_path = apply_default_extension(output_path, output_type) unless output_path.nil?
+      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)
 
-      input_files = Array(input_files)
       flags = translate_flags(flags)
       flags.concat(xflags[@toolchain.class] || [])
 
-      cmd = @toolchain.command(input_files, output_path, flags, include_paths, defs, libs, linker_paths)
-      run_command(cmd, env:, working_dir:) ? (output_path || true) : nil
+      cmds = @toolchain.compile_and_link_commands(
+        input_files,
+        output_path,
+        flags:,
+        include_paths:,
+        defs:,
+        libs:,
+        link_paths:
+      )
+
+      cmds.each { |cmd| run_command(cmd, env:, working_dir:) }
+      output_path
     end
 
     private
@@ -93,15 +137,8 @@ module MetaCC
         toolchain = toolchain_class.new(search_paths:)
         return toolchain if toolchain.available?
       end
-      raise CompilerNotFoundError, "No supported C/C++ compiler found (tried clang, gcc, cl)"
-    end
-
-    def output_type_from_flags(flags)
-      if flags.include?(:objects)    then :objects
-      elsif flags.include?(:shared)  then :shared
-      elsif flags.include?(:static)  then :static
-      else :executable
-      end
+      candidate_names = candidates.map { |candidate| candidate.name.split("::").last }
+      raise ToolchainNotFoundError, "no supported C/C++ toolchain found (tried #{candidate_names.join(", ")})"
     end
 
     def apply_default_extension(path, output_type)
@@ -121,7 +158,8 @@ module MetaCC
     end
 
     def run_command(cmd, env: {}, working_dir: ".")
-      !!system(env, *cmd, chdir: working_dir, out: File::NULL, err: File::NULL)
+      _out, err, status = Open3.capture3(env, *cmd, chdir: working_dir)
+      raise CompileError, err unless status.success?
     end
 
   end

data/lib/metacc/toolchain.rb

@@ -17,7 +17,7 @@ module MetaCC
       @search_paths = search_paths
     end
 
-    # Returns true if this toolchain's primary compiler is present in PATH.
+    # Returns true if this toolchain's primary compiler can be found
     def available?
       command_available?(c)
     end
@@ -26,14 +26,12 @@ module MetaCC
     # The default implementation returns [:c, :cxx].  Subclasses that only
     # support a subset of languages should override this method.
     def languages
-      [:c, :cxx]
+      %i[c cxx]
     end
 
     # Returns true if +command+ is present in PATH, false otherwise.
     # Intentionally ignores the exit status – only ENOENT (not found) matters.
     def command_available?(command)
-      return false if command.nil?
-
       !system(command, "--version", out: File::NULL, err: File::NULL).nil?
     end
 
@@ -44,14 +42,31 @@ module MetaCC
 
     # Returns a Hash mapping universal flags to native flags for this toolchain.
     def flags
-      raise RuntimeError, "#{self.class}#flags not implemented"
+      raise "#{self.class}#flags not implemented"
     end
 
     # Returns the full command array for the given inputs, output, and flags.
     # The output mode (object files, shared library, static library, or
     # executable) is determined by the translated flags.
-    def command(input_files, output, flags, include_paths, definitions, libs, linker_include_dirs)
-      raise RuntimeError, "#{self.class}#command not implemented"
+    def compile_command(
+      input_files,
+      flags:,
+      include_paths:,
+      defs:
+    )
+      raise "#{self.class}#command not implemented"
+    end
+
+    def compile_and_link_commands(
+      input_files,
+      output_file,
+      flags:,
+      include_paths:,
+      defs:,
+      link_paths:,
+      libs:
+    )
+      raise "#{self.class}#command not implemented"
     end
 
     # Returns the default file extension (with leading dot, e.g. ".o") for the
@@ -102,57 +117,73 @@ module MetaCC
   # GNU-compatible toolchain (gcc).
   class GNU < Toolchain
 
-    def initialize(search_paths: [])
-      super
-      @c    = resolve_command("gcc")
+    def initialize(cc_command = "gcc", search_paths: [])
+      super(search_paths:)
+      @c = resolve_command(cc_command)
     end
 
-    def command(input_files, output, flags, include_paths, definitions, libs, linker_include_dirs)
+    def compile_command(
+      input_files,
+      flags:,
+      include_paths:,
+      defs:
+    )
       inc_flags = include_paths.map { |p| "-I#{p}" }
-      def_flags = definitions.map { |d| "-D#{d}" }
-      link_mode = !flags.include?("-c")
-      lib_path_flags = link_mode ? linker_include_dirs.map { |p| "-L#{p}" } : []
-      lib_flags      = link_mode ? libs.map { |l| "-l#{l}" } : []
-      cmd = [c, *flags, *inc_flags, *def_flags, *input_files, *lib_path_flags, *lib_flags]
-      output.nil? ? cmd : [*cmd, "-o", output]
+      def_flags = defs.map { |d| "-D#{d}" }
+      [c, "-c", *flags, *inc_flags, *def_flags, *input_files]
+    end
+
+    def compile_and_link_commands(
+      input_files,
+      output_file,
+      flags:,
+      include_paths:,
+      defs:,
+      link_paths:,
+      libs:
+    )
+      inc_flags = include_paths.map { |p| "-I#{p}" }
+      def_flags = defs.map { |d| "-D#{d}" }
+      lib_path_flags = link_paths.map { |p| "-L#{p}" }
+      lib_flags      = libs.map { |l| "-l#{l}" }
+      [[c, *flags, *inc_flags, *def_flags, *input_files, *lib_path_flags, *lib_flags, "-o", output_file]]
     end
 
     GNU_FLAGS = {
-      o0:            ["-O0"],
-      o1:            ["-O1"],
-      o2:            ["-O2"],
-      o3:            ["-O3"],
-      os:            ["-Os"],
-      sse4_2:        ["-march=x86-64-v2"], # This is a better match for /arch:SSE4.2 than -msse4_2 is
-      avx:           ["-march=x86-64-v2", "-mavx"],
-      avx2:          ["-march=x86-64-v3"], # This is a better match for /arch:AVX2 than -mavx2 is
-      avx512:        ["-march=x86-64-v4"],
-      native:        ["-march=native", "-mtune=native"],
-      debug:         ["-g3"],
-      lto:           ["-flto"],
-      warn_all:      ["-Wall", "-Wextra", "-pedantic"],
-      warn_error:    ["-Werror"],
-      c11:           ["-std=c11"],
-      c17:           ["-std=c17"],
-      c23:           ["-std=c23"],
-      cxx11:         ["-std=c++11"],
-      cxx14:         ["-std=c++14"],
-      cxx17:         ["-std=c++17"],
-      cxx20:         ["-std=c++20"],
-      cxx23:         ["-std=c++23"],
-      cxx26:         ["-std=c++2c"],
-      asan:          ["-fsanitize=address"],
-      ubsan:         ["-fsanitize=undefined"],
-      msan:          ["-fsanitize=memory"],
+      o0:                        ["-O0"],
+      o1:                        ["-O1"],
+      o2:                        ["-O2"],
+      o3:                        ["-O3"],
+      os:                        ["-Os"],
+      sse4_2:                    ["-march=x86-64-v2"], # This is a better match for /arch:SSE4.2 than -msse4_2 is
+      avx:                       ["-march=x86-64-v2", "-mavx"],
+      avx2:                      ["-march=x86-64-v3"], # This is a better match for /arch:AVX2 than -mavx2 is
+      avx512:                    ["-march=x86-64-v4"],
+      native:                    ["-march=native", "-mtune=native"],
+      debug:                     ["-g3"],
+      lto:                       ["-flto"],
+      warn_all:                  ["-Wall", "-Wextra", "-pedantic"],
+      warn_error:                ["-Werror"],
+      c11:                       ["-std=c11"],
+      c17:                       ["-std=c17"],
+      c23:                       ["-std=c23"],
+      cxx11:                     ["-std=c++11"],
+      cxx14:                     ["-std=c++14"],
+      cxx17:                     ["-std=c++17"],
+      cxx20:                     ["-std=c++20"],
+      cxx23:                     ["-std=c++23"],
+      cxx26:                     ["-std=c++2c"],
+      asan:                      ["-fsanitize=address"],
+      ubsan:                     ["-fsanitize=undefined"],
+      msan:                      ["-fsanitize=memory"],
       no_rtti:                   ["-fno-rtti"],
       no_exceptions:             ["-fno-exceptions", "-fno-unwind-tables"],
       pic:                       ["-fPIC"],
       no_semantic_interposition: ["-fno-semantic-interposition"],
       no_omit_frame_pointer:     ["-fno-omit-frame-pointer"],
       no_strict_aliasing:        ["-fno-strict-aliasing"],
-      objects:                   ["-c"],
       shared:                    ["-shared"],
-      static:                    ["-r", "-nostdlib"],
+      static:                    ["-static"],
       strip:                     ["-Wl,--strip-unneeded"]
     }.freeze
 
@@ -166,8 +197,7 @@ module MetaCC
   class Clang < GNU
 
     def initialize(search_paths: [])
-      super
-      @c    = resolve_command("clang")
+      super("clang", search_paths:)
     end
 
     CLANG_FLAGS = GNU_FLAGS.merge(lto: ["-flto=thin"]).freeze
@@ -190,24 +220,37 @@ module MetaCC
     def initialize(cl_command = "cl", search_paths: [])
       super(search_paths:)
       resolved_cmd = resolve_command(cl_command)
-      @c    = resolved_cmd
+      @c = resolved_cmd
       setup_msvc_environment(resolved_cmd)
     end
 
-    def command(input_files, output, flags, include_paths, definitions, libs, linker_include_dirs)
+    def compile_command(
+      input_files,
+      flags:,
+      include_paths:,
+      defs:
+    )
       inc_flags = include_paths.map { |p| "/I#{p}" }
-      def_flags = definitions.map { |d| "/D#{d}" }
-
-      if flags.include?("/c")
-        cmd = [c, *flags, *inc_flags, *def_flags, *input_files]
-        output.nil? ? cmd : [*cmd, "/Fo#{output}"]
-      else
-        lib_flags      = libs.map { |l| "#{l}.lib" }
-        lib_path_flags = linker_include_dirs.map { |p| "/LIBPATH:#{p}" }
-        cmd = [c, *flags, *inc_flags, *def_flags, *input_files, *lib_flags, "/Fe#{output}"]
-        cmd += ["/link", *lib_path_flags] unless lib_path_flags.empty?
-        cmd
-      end
+      def_flags = defs.map { |d| "/D#{d}" }
+      [c, "/c", *flags, *inc_flags, *def_flags, *input_files]
+    end
+
+    def compile_and_link_commands(
+      input_files,
+      output_file,
+      flags:,
+      include_paths:,
+      defs:,
+      link_paths:,
+      libs:
+    )
+      inc_flags = include_paths.map { |p| "/I#{p}" }
+      def_flags = defs.map { |d| "/D#{d}" }
+      lib_flags      = libs.map { |l| "#{l}.lib" }
+      lib_path_flags = link_paths.map { |p| "/LIBPATH:#{p}" }
+      cmd = [c, *flags, *inc_flags, *def_flags, *input_files, *lib_flags, "/Fe#{output_file}"]
+      cmd += ["/link", *lib_path_flags] unless lib_path_flags.empty?
+      [cmd]
     end
 
     MSVC_FLAGS = {
@@ -243,7 +286,6 @@ module MetaCC
       no_semantic_interposition: [],
       no_omit_frame_pointer:     ["/Oy-"],
       no_strict_aliasing:        [],
-      objects:                   ["/c"],
       shared:                    ["/LD"],
       static:                    ["/c"],
       strip:                     []
@@ -285,70 +327,55 @@ module MetaCC
     def setup_msvc_environment(cl_command)
       return if command_available?(cl_command)
 
-      devenv_path = run_vswhere("-path", "-property", "productPath") ||
-                    run_vswhere("-latest", "-prerelease", "-property", "productPath")
+      devenv_path = MSVC.vswhere("-path", "-property", "productPath") ||
+                    MSVC.vswhere("-latest", "-prerelease", "-property", "productPath")
       return unless devenv_path
 
-      vcvarsall = find_vcvarsall(devenv_path)
-      return unless vcvarsall
-
-      run_vcvarsall(vcvarsall)
+      MSVC.vcvarsall(devenv_path)
     end
 
     # Runs vswhere.exe with the given arguments and returns the trimmed stdout,
     # or nil if vswhere.exe is absent, the command fails, or produces no output.
-    def run_vswhere(*args)
-      return nil unless File.exist?(VSWHERE_PATH)
-
-      stdout = IO.popen([VSWHERE_PATH, *args], &:read)
+    def self.vswhere(*args)
+      path = IO.popen([VSWHERE_PATH, *args], &:read).strip
       status = $?
-      return nil unless status.success?
 
-      path = stdout.strip
-      path.empty? ? nil : path
+      status.success? && !path.empty? ? path : nil
     rescue Errno::ENOENT
       nil
     end
 
-    # Returns the path to vcvarsall.bat for the given devenv.exe path, or nil
+    # Runs vcvarsall.bat for the x64 architecture and merges the resulting
+    # environment variables into the current process's ENV so that cl.exe
+    # and related tools become available on PATH.
+    #
+    # Finds the path to vcvarsall.bat for the given devenv.exe path, or nil
     # if it cannot be located.  devenv.exe lives at:
     #   <root>\Common7\IDE\devenv.exe
     # vcvarsall.bat lives at:
     #   <root>\VC\Auxiliary\Build\vcvarsall.bat
-    def find_vcvarsall(devenv_path)
+    #
+    # Parses the output of `vcvarsall.bat … && set` and merges the resulting
+    # environment variables into the current process's ENV.
+    def MSVC.vcvarsall(devenv_path)
+      # See https://stackoverflow.com/a/19929778
+      return if ENV.has_key?("DevEnvDir")
+
+      # Calculate the location of vcvarsall.bat
       install_root = File.expand_path("../../..", devenv_path)
+
+      # Check if a file is actually present there
       vcvarsall = File.join(install_root, "VC", "Auxiliary", "Build", "vcvarsall.bat")
-      File.exist?(vcvarsall) ? vcvarsall : nil
-    end
+      return unless File.exist?(vcvarsall)
 
-    # Runs vcvarsall.bat for the x64 architecture and merges the resulting
-    # environment variables into the current process's ENV so that cl.exe
-    # and related tools become available on PATH.
-    def run_vcvarsall(vcvarsall)
-      stdout = IO.popen(["cmd.exe", "/c", vcvarsall_command(vcvarsall)], &:read)
+      # Run vcvarsall.bat and dump the environment to the shell
+      output = `"#{vcvarsall}" x64 && set`
       status = $?
       return unless status.success?
 
-      load_vcvarsall(stdout)
-    end
-
-    # Builds the cmd.exe command string for calling vcvarsall.bat and capturing
-    # the resulting environment variables.  The path is double-quoted to handle
-    # spaces; any embedded double quotes are escaped by doubling them, which is
-    # the cmd.exe convention inside a double-quoted string.  Shellwords is not
-    # used here because it produces POSIX sh escaping, which is incompatible
-    # with cmd.exe syntax.
-    def vcvarsall_command(vcvarsall)
-      quoted = '"' + vcvarsall.gsub('"', '""') + '"'
-      "#{quoted} x64 && set"
-    end
-
-    # Parses the output of `vcvarsall.bat … && set` and merges the resulting
-    # environment variables into the current process's ENV.
-    def load_vcvarsall(output)
       output.each_line do |line|
-        key, sep, value = line.chomp.partition("=")
-        next if sep.empty?
+        key, value = line.chomp.split("=", 2)
+        next if value.to_s.empty?
 
         ENV[key] = value
       end
@@ -376,11 +403,19 @@ module MetaCC
   end
 
   # TinyCC toolchain (tcc).  TinyCC only supports C, not C++.
-  class TinyCC < Toolchain
+  class TinyCC < GNU
 
     def initialize(search_paths: [])
-      super
-      @c   = resolve_command("tcc")
+      super("tcc", search_paths:)
+      @ar = resolve_command("ar")
+    end
+
+    def compile_and_link_commands(input_files, output_file, **options)
+      commands = super(input_files, output_file, **options)
+      if options[:flags].include?(:static)
+        object_files = input_files.map { |f| f.sub(/\.c\z/, ".o") }
+        commands << [@ar, "rcs", output_file, *object_files]
+      end
     end
 
     # TinyCC does not support C++.
@@ -388,14 +423,8 @@ module MetaCC
       [:c]
     end
 
-    def command(input_files, output, flags, include_paths, definitions, libs, linker_include_dirs)
-      inc_flags = include_paths.map { |p| "-I#{p}" }
-      def_flags = definitions.map { |d| "-D#{d}" }
-      link_mode = !flags.include?("-c")
-      lib_path_flags = link_mode ? linker_include_dirs.map { |p| "-L#{p}" } : []
-      lib_flags      = link_mode ? libs.map { |l| "-l#{l}" } : []
-      cmd = [c, *flags, *inc_flags, *def_flags, *input_files, *lib_path_flags, *lib_flags]
-      output.nil? ? cmd : [*cmd, "-o", output]
+    def version_banner
+      IO.popen([c, "-v", { err: :out }], &:read)
     end
 
     TINYCC_FLAGS = {
@@ -431,7 +460,6 @@ module MetaCC
       no_semantic_interposition: [],
       no_omit_frame_pointer:     [],
       no_strict_aliasing:        [],
-      objects:                   ["-c"],
       shared:                    ["-shared"],
       static:                    ["-c"],
       strip:                     []

data/lib/metacc/version.rb

@@ -0,0 +1,5 @@
+module MetaCC
+
+  VERSION = "0.2.0"
+
+end

data/lib/metacc.rb

@@ -1,9 +1,4 @@
 # frozen_string_literal: true
 
 require "metacc/driver"
-
-module MetaCC
-
-  VERSION = "0.1.0"
-
-end
+require "metacc/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metacc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Praneeth Sadda
@@ -23,9 +23,13 @@ files:
 - lib/metacc/cli.rb
 - lib/metacc/driver.rb
 - lib/metacc/toolchain.rb
+- lib/metacc/version.rb
+homepage: https://github.com/psadda/metacc
 licenses:
 - BSD-3-Clause
 metadata:
+  homepage_uri: https://github.com/psadda/metacc
+  source_code_uri: https://github.com/psadda/metacc
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -34,7 +38,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="