metacc 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f277277e6c19c84a200cf69d21452da422980b3955c895bc148666b2e170d7c
-  data.tar.gz: e17a0627af2e670202be743c4e745a6aedaf10284ead45cd7c6740dd64dcf4b0
+  metadata.gz: d74b463f2d62a82dbbe422b47e112052a25c95e8c51b957f01ec2545b2f8f227
+  data.tar.gz: 510bdbcba0c031de7909db0a989141afbecd9fa33bcf7b5066cf61d3dacc6f49
 SHA512:
-  metadata.gz: d889eff550e1f704c4e4264d750c1d03ddd7e040c1303eb6147501de5b0b2eec970c595cf183afe6fe7da91ee9465c0aa70f7596887018d3b9f4e979801e9f27
-  data.tar.gz: 9a0ae1d9c54d117d809dc236396ee0d4a69b321161a535287195474cdd6845a78dc0352bfe0b51f80487dbe25d9194a2afb98320ed2c90ff458f857d2be92f53
+  metadata.gz: bbfda6722b4f9fa4b59a6be206a1b5ca0503d77f5833dbe5ba07f46525b1f157e4ac5ca7853f0f18ae7efd4f9c2782993a0991e101fd102523323abfeea97dd1
+  data.tar.gz: 15f59e0d6f45de8501b38aa6429624dd759d7d7b126ce18c0def60bdd2d56648f4b116483753e2f93da60c3e205ec5fd00813844e59b4975d7e3c81c01cfd590

data/bin/metacc

@@ -5,4 +5,16 @@ $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,
+       OptionParser::AmbiguousOption,
+       OptionParser::MissingArgument,
+       OptionParser::NeedlessArgument,
+       OptionParser::InvalidArgument,
+       OptionParser::InvalidOption => e
+  warn "#{$0} error: #{e.message}"
+rescue MetaCC::CompileError => e
+  warn e.message
+end

data/lib/metacc/cli.rb

@@ -9,57 +9,23 @@ module MetaCC
   #
   # Usage:
   #   metacc <sources...> -o <output> [options]       – compile source file(s)
-  #
-  # General:
-  #   -Wall -Werror
-  #   --std=c11 --std=c17 --std=c23
-  #   --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
-  #   -l, -L             - specify linker input
-  #   --shared           – produce a shared library
-  #   --static           – produce a static library
-  #   --lto              - enable link time optimization
-  #   --strip / -s       – strip unneeded symbols
-  #
-  # Code generation:
-  #   -O0, -O1, -O2, -O3                             - Set the optimization level
-  #   -msse4.2 -mavx -mavx2 -mavx512 --arch=native   - Compile for the given target
-  #   --no-rtti --no-exceptions
-  #   --pic
-  #
-  # Debugging:
-  #   --debug / -g
-  #   --asan --ubsan --msan
-  #
-  # Toolchain-specific flags (passed to Driver#compile via xflags:):
-  #   --xmsvc VALUE     – appended to xflags[MSVC]
-  #   --xgnu  VALUE     – appended to xflags[GNU]
-  #   --xclang VALUE    – appended to xflags[Clang]
-  #   --xclangcl VALUE  – appended to xflags[ClangCL]
   class CLI
 
-    # Maps long-form CLI flag names to Driver::RECOGNIZED_FLAGS symbols.
-    # Optimization-level flags are handled separately via -O LEVEL.
-    LONG_FLAGS = {
-      "lto" =>                       :lto,
-      "asan" =>                      :asan,
-      "ubsan" =>                     :ubsan,
-      "msan" =>                      :msan,
-      "no-rtti" =>                   :no_rtti,
-      "no-exceptions" =>             :no_exceptions,
-      "pic" =>                       :pic,
-      "no-semantic-interposition" => :no_semantic_interposition,
-      "no-omit-frame-pointer" =>     :no_omit_frame_pointer,
-      "no-strict-aliasing" =>        :no_strict_aliasing
-    }.freeze
-
     WARNING_CONFIGS = {
       "all" =>   :warn_all,
       "error" => :warn_error
     }
 
+    SANITIZERS = {
+      "address" =>   :asan,
+      "addr" =>      :asan,
+      "undefined" => :ubsan,
+      "ub" =>        :ubsan,
+      "memory" =>    :msan,
+      "mem" =>       :msan,
+      "leak" =>      :lsan
+    }
+
     TARGETS = {
       "sse4.2" => :sse4_2,
       "avx" =>    :avx,
@@ -69,9 +35,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 +48,52 @@ module MetaCC
 
     # Maps --x<name> CLI option names to xflags toolchain-class keys.
     XFLAGS = {
-      "xmsvc" =>    MSVC,
-      "xgnu" =>     GNU,
-      "xclang" =>   Clang,
-      "xclangcl" => ClangCL
+      "xmsvc" => MSVC,
+      "xgnu" => GNU,
+      "xclang" => Clang,
+      "xclangcl" => ClangCL,
+      "xtinycc" => TinyCC
     }.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.require_exact = true
+
+      parser.separator ""
+      parser.separator "General options:"
+
       parser.on("-o FILEPATH", "Output file path") do |value|
         options[:output_path] = value
       end
@@ -127,89 +103,131 @@ 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}"
+      parser.on("--std=STANDARD", "Specify the language standard") do |value|
+        options[:flags] << STANDARDS[value]
       end
-      parser.on("-Os", "Optimize for size") do
-        options[:flags] << :os
+      parser.on("-W OPTION", "Configure warnings") do |value|
+        options[:flags] << WARNING_CONFIGS[value]
       end
-      parser.on("-m", "--arch ARCH", "Target architecture") do |value|
-        options[:flags] << TARGETS[v]
+      parser.on("-r", "--run", "Run the compiled executable after a successful build") do
+        options[:run] = true
       end
-      parser.on("-g", "--debug", "Emit debugging symbols") do
-        options[:flags] << :debug
+
+      parser.separator ""
+      parser.separator "Debugging:"
+
+      parser.on("-g", "--debug-info", "Emit debugging symbols") do
+        options[:flags] << :debug_info
       end
-      parser.on("--std STANDARD", "Specify the language standard") do |value|
-        options[:flags] << STANDARDS[v]
+      parser.on("-S", "--sanitize SANITIZER", "Enable sanitizer (address, undefined, leak, memory)") do |value|
+        options[:flags] << SANITIZERS[value]
       end
-      parser.on("-W OPTION", "Configure warnings") do |value|
-        options[:flags] << WARNING_CONFIGS[v]
+
+      parser.separator ""
+      parser.separator "Optimization:"
+
+      parser.on("-O LEVEL", /\A[0-3]|s\z/, "Optimization level (0, 1, 2, 3, or s)") do |level|
+        options[:flags] << :"o#{level}"
       end
-      parser.on("-c", "--objects", "Produce object files") do
-        options[:flags] << :objects
+      parser.on("--lto", "Enable link time optimization") do
+        options[:flags] << :lto
       end
-      parser.on("-r", "--run", "Run the compiled executable after a successful build") do
-        options[:run] = true
+      parser.on("--omit-frame-pointer") do |value|
+        options[:flags] << :omit_frame_pointer
       end
-      parser.on("-l LIB", "Link against library LIB") do |value|
-        options[:libs] << value
+      parser.on("--strict-aliasing") do |value|
+        options[:flags] << :strict_aliasing
       end
-      parser.on("-L DIR", "Add linker library search path") do |value|
-        options[:linker_paths] << value
+
+      parser.separator ""
+      parser.separator "Code generation:"
+
+      parser.on("-m", "--arch=ARCH", "Target architecture") do |value|
+        options[:flags] << TARGETS[value]
       end
-      parser.on("--shared", "Produce a shared library") do
-        options[:flags] << :shared
+      parser.on("--pic", "Generate position independent code") do |value|
+        options[:flags] << :pic
+      end
+      parser.on("--no-rtti", "Disable runtime type information") do |value|
+        options[:flags] << :no_rtti
       end
+      parser.on("--no-exceptions", "Disable exceptions (and unwinding info)") do |value|
+        options[:flags] << :no_exceptions
+      end
+
+      parser.separator ""
+      parser.separator "Linking:"
+
       parser.on("--static", "Produce a static library") do
         options[:flags] << :static
       end
+      parser.on("--shared", "Produce a shared library") do |value|
+        options[:flags] << :shared
+      end
+      parser.on("--shared-compat", "Produce a shared library with full LD_PRELOAD compatability") do |value|
+        options[:flags] << :shared_compat
+      end
+      parser.on("-c", "Compile only (produce object files without linking)") do
+        options[:link] = false
+      end
+      parser.on("-l LIB", "Link against library LIB") do |value|
+        options[:libs] << value
+      end
+      parser.on("-L DIR", "Add linker library search path") do |value|
+        options[:link_paths] << value
+      end
+
       parser.on("-s", "--strip", "Strip unneeded symbols") do
         options[:flags] << :strip
       end
-      LONG_FLAGS.each do |name, sym|
-        parser.on("--#{name}") do
-          options[:flags] << sym
-        end
-      end
-      XFLAGS.each do |name, tc_class|
-        parser.on("--#{name} VALUE", "Pass VALUE to the #{tc_class} toolchain") do |value|
-          options[:xflags][tc_class] ||= []
-          options[:xflags][tc_class] << value
+
+      parser.separator ""
+      parser.separator "Compiler specific:"
+
+      XFLAGS.each do |name, toolchain_class|
+        toolchain_name = toolchain_class.name.split("::").last
+        parser.on("--#{name} FLAG", "Forward FLAG to the compiler if compiling with #{toolchain_name}") do |value|
+          options[:xflags][toolchain_class] ||= []
+          options[:xflags][toolchain_class] << value
         end
       end
+
+      parser.separator ""
+      parser.separator "Informational:"
+
       parser.on_tail("--version", "Print the toolchain version and exit") do
-        puts driver&.toolchain&.version_banner
+        puts @driver.toolchain.version_banner
+        exit
+      end
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
         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 OptionParser::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 OptionParser::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 OptionParser::InvalidOption, "--run may not be used with -c, --shared, or --static"
       end
     end
 
-    def run_executable(path)
-      system(path)
-    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
+    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
 
   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).
@@ -13,16 +17,16 @@ module MetaCC
 
     RECOGNIZED_FLAGS = Set.new(
       %i[
-        o0 o1 o2 o3 os
-        sse4_2 avx avx2 avx512 native
-        debug lto
         warn_all warn_error
         c11 c17 c23
         cxx11 cxx14 cxx17 cxx20 cxx23 cxx26
-        asan ubsan msan
-        no_rtti no_exceptions pic
-        no_semantic_interposition no_omit_frame_pointer no_strict_aliasing
-        objects shared static strip
+        o0 o1 o2 o3 os lto
+        sse4_2 avx avx2 avx512 native
+        asan ubsan msan lsan
+        debug_info
+        omit_frame_pointer strict_aliasing
+        no_rtti no_exceptions
+        pic shared shared_compat 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)
@@ -117,11 +154,15 @@ module MetaCC
         raise "#{unrecognized_flag.inspect} is not a known flag"
       end
 
+      flags << :no_omit_frame_pointer unless flags.include?(:omit_frame_pointer)
+      flags << :no_strict_aliasing unless flags.include?(:strict_aliasing)
+
       flags.flat_map { |flag| @toolchain.flags[flag] }
     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,58 +117,78 @@ 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"],
-      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"],
-      strip:                     ["-Wl,--strip-unneeded"]
+      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_info:            ["-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"],
+      lsan:                  ["-fsanitize=leak"],
+      no_rtti:               ["-fno-rtti"],
+      no_exceptions:         ["-fno-exceptions", "-fno-unwind-tables"],
+      pic:                   ["-fPIC"],
+      omit_frame_pointer:    ["-fomit-frame-pointer"],
+      no_omit_frame_pointer: ["-fno-omit-frame-pointer"],
+      strict_aliasing:       ["-fstrict-aliasing"],
+      no_strict_aliasing:    ["-fno-strict-aliasing"],
+      shared:                ["-shared", "-Bsymbolic-non-weak-functions", "-fno-semantic-interposition"],
+      shared_compat:         ["-shared"],
+      static:                ["-static"],
+      strip:                 ["-Wl,--strip-unneeded"],
+      debug:                 ["-D_GLIBCXX_DEBUG", "-fasynchronous-unwind-tables"]
     }.freeze
 
     def flags
@@ -166,8 +201,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,63 +224,78 @@ 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 = {
-      o0:                        ["/Od"],
-      o1:                        ["/O1"],
-      o2:                        ["/O2"],
-      o3:                        ["/O2", "/Ob3"],
-      os:                        ["/O1"],
-      sse4_2:                    ["/arch:SSE4.2"],
-      avx:                       ["/arch:AVX"],
-      avx2:                      ["/arch:AVX2"],
-      avx512:                    ["/arch:AVX512"],
-      native:                    [],
-      debug:                     ["/Zi"],
-      lto:                       ["/GL"],
-      warn_all:                  ["/W4"],
-      warn_error:                ["/WX"],
-      c11:                       ["/std:c11"],
-      c17:                       ["/std:c17"],
-      c23:                       ["/std:clatest"],
-      cxx11:                     [],
-      cxx14:                     ["/std:c++14"],
-      cxx17:                     ["/std:c++17"],
-      cxx20:                     ["/std:c++20"],
-      cxx23:                     ["/std:c++23preview"],
-      cxx26:                     ["/std:c++latest"],
-      asan:                      ["/fsanitize=address"],
-      ubsan:                     [],
-      msan:                      [],
-      no_rtti:                   ["/GR-"],
-      no_exceptions:             ["/EHs-", "/EHc-"],
-      pic:                       [],
-      no_semantic_interposition: [],
-      no_omit_frame_pointer:     ["/Oy-"],
-      no_strict_aliasing:        [],
-      objects:                   ["/c"],
-      shared:                    ["/LD"],
-      static:                    ["/c"],
-      strip:                     []
+      o0:                    ["/Od"],
+      o1:                    ["/O1"],
+      o2:                    ["/O2"],
+      o3:                    ["/O2", "/Ob3"],
+      os:                    ["/O1"],
+      sse4_2:                ["/arch:SSE4.2"],
+      avx:                   ["/arch:AVX"],
+      avx2:                  ["/arch:AVX2"],
+      avx512:                ["/arch:AVX512"],
+      native:                [],
+      debug_info:            ["/Zi"],
+      lto:                   ["/GL"],
+      warn_all:              ["/W4"],
+      warn_error:            ["/WX"],
+      c11:                   ["/std:c11"],
+      c17:                   ["/std:c17"],
+      c23:                   ["/std:clatest"],
+      cxx11:                 [],
+      cxx14:                 ["/std:c++14"],
+      cxx17:                 ["/std:c++17"],
+      cxx20:                 ["/std:c++20"],
+      cxx23:                 ["/std:c++23preview"],
+      cxx26:                 ["/std:c++latest"],
+      asan:                  ["/fsanitize=address"],
+      ubsan:                 [],
+      msan:                  [],
+      lsan:                  [],
+      no_rtti:               ["/GR-"],
+      no_exceptions:         ["/EHs-", "/EHc-"],
+      pic:                   [],
+      omit_frame_pointer:    ["/Oy"],
+      no_omit_frame_pointer: ["/Oy-"],
+      strict_aliasing:       ["-fstrict-aliasing"],
+      no_strict_aliasing:    ["-fno-strict-aliasing"],
+      shared:                ["/LD"],
+      shared_compat:         ["/LD"],
+      static:                ["/c"],
+      strip:                 []
     }.freeze
 
     def flags
@@ -285,70 +334,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 +410,20 @@ 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
+      commands
     end
 
     # TinyCC does not support C++.
@@ -388,53 +431,47 @@ 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 = {
-      o0:                        [],
-      o1:                        ["-O1"],
-      o2:                        ["-O2"],
-      o3:                        ["-O2"],
-      os:                        [],
-      sse4_2:                    [],
-      avx:                       [],
-      avx2:                      [],
-      avx512:                    [],
-      native:                    [],
-      debug:                     ["-g"],
-      lto:                       [],
-      warn_all:                  ["-Wall"],
-      warn_error:                ["-Werror"],
-      c11:                       [],
-      c17:                       [],
-      c23:                       [],
-      cxx11:                     [],
-      cxx14:                     [],
-      cxx17:                     [],
-      cxx20:                     [],
-      cxx23:                     [],
-      cxx26:                     [],
-      asan:                      [],
-      ubsan:                     [],
-      msan:                      [],
-      no_rtti:                   [],
-      no_exceptions:             [],
-      pic:                       [],
-      no_semantic_interposition: [],
-      no_omit_frame_pointer:     [],
-      no_strict_aliasing:        [],
-      objects:                   ["-c"],
-      shared:                    ["-shared"],
-      static:                    ["-c"],
-      strip:                     []
+      o0:                 [],
+      o1:                 ["-O1"],
+      o2:                 ["-O2"],
+      o3:                 ["-O2"],
+      os:                 [],
+      sse4_2:             [],
+      avx:                [],
+      avx2:               [],
+      avx512:             [],
+      native:             [],
+      debug_info:         ["-g"],
+      lto:                [],
+      warn_all:           ["-Wall"],
+      warn_error:         ["-Werror"],
+      c11:                [],
+      c17:                [],
+      c23:                [],
+      cxx11:              [],
+      cxx14:              [],
+      cxx17:              [],
+      cxx20:              [],
+      cxx23:              [],
+      cxx26:              [],
+      asan:               [],
+      ubsan:              [],
+      msan:               [],
+      leak:               [],
+      no_rtti:            [],
+      no_exceptions:      [],
+      pic:                [],
+      keep_frame_pointer: [],
+      relaxed_aliasing:   [],
+      shared:             ["-shared"],
+      shared_compat:      ["-shared"],
+      static:             ["-c"],
+      strip:              []
     }.freeze
 
     def flags

data/lib/metacc/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MetaCC
+
+  VERSION = "0.3.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.3.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:
   - - ">="