#!/usr/bin/env python

import argparse
import os
import platform
import shutil
import signal
import subprocess
import sys

if sys.platform == "win32":
    # This module was renamed in Python 3.  Make sure to import it using a
    # consistent name regardless of python version.
    try:
        import winreg
    except:
        import _winreg as winreg

if __name__ != "__main__":
    raise RuntimeError("Do not import this script, run it instead")


parser = argparse.ArgumentParser(description="LLDB compilation wrapper")
parser.add_argument(
    "--arch",
    metavar="arch",
    dest="arch",
    required=True,
    default="host",
    choices=["32", "64", "host"],
    help="Specify the architecture to target.",
)

parser.add_argument(
    "--compiler",
    metavar="compiler",
    dest="compiler",
    required=True,
    help="Path to a compiler executable, or one of the values [any, msvc, clang-cl, gcc, clang]",
)

parser.add_argument(
    "--libs-dir",
    metavar="directory",
    dest="libs_dir",
    required=False,
    action="append",
    help="If specified, a path to linked libraries to be passed via -L",
)

parser.add_argument(
    "--tools-dir",
    metavar="directory",
    dest="tools_dir",
    required=False,
    action="append",
    help="If specified, a path to search in addition to PATH when --compiler is not an exact path",
)

parser.add_argument(
    "--objc-gnustep-dir",
    metavar="directory",
    dest="objc_gnustep_dir",
    required=False,
    help="If specified, a path to GNUstep libobjc2 runtime for use on Windows and Linux",
)

parser.add_argument(
    "--objc-gnustep",
    dest="objc_gnustep",
    action="store_true",
    default=False,
    help="Include and link GNUstep libobjc2 (Windows and Linux only)",
)

parser.add_argument(
    "--sysroot",
    metavar="directory",
    dest="sysroot",
    required=False,
    help="If specified, a sysroot to be passed via --sysroot",
)

if sys.platform == "darwin":
    parser.add_argument(
        "--apple-sdk",
        metavar="apple_sdk",
        dest="apple_sdk",
        default="macosx",
        help="Specify the name of the Apple SDK (macosx, macosx.internal, iphoneos, iphoneos.internal, or path to SDK) and use the appropriate tools from that SDK's toolchain.",
    )

parser.add_argument(
    "--output",
    "-o",
    dest="output",
    metavar="file",
    required=False,
    default="",
    help="Path to output file",
)

parser.add_argument(
    "--outdir",
    "-d",
    dest="outdir",
    metavar="directory",
    required=False,
    help="Directory for output files",
)

parser.add_argument(
    "--nodefaultlib",
    dest="nodefaultlib",
    action="store_true",
    default=False,
    help="When specified, the resulting image should not link against system libraries or include system headers.  Useful when writing cross-targeting tests.",
)

parser.add_argument(
    "--opt",
    dest="opt",
    default="none",
    choices=["none", "basic", "lto"],
    help="Optimization level",
)

parser.add_argument(
    "--mode",
    dest="mode",
    default="compile-and-link",
    choices=["compile", "link", "compile-and-link"],
    help="Specifies whether to compile, link, or both",
)

parser.add_argument(
    "--noclean",
    dest="clean",
    action="store_false",
    default=True,
    help="Dont clean output file before building",
)

parser.add_argument(
    "--verbose",
    dest="verbose",
    action="store_true",
    default=False,
    help="Print verbose output",
)

parser.add_argument(
    "-n",
    "--dry-run",
    dest="dry",
    action="store_true",
    default=False,
    help="Print the commands that would run, but dont actually run them",
)

parser.add_argument(
    "inputs",
    metavar="file",
    nargs="+",
    help="Source file(s) to compile / object file(s) to link",
)

parser.add_argument(
    "--std",
    metavar="std",
    dest="std",
    required=False,
    help="Specify the C/C++ standard.",
)


args = parser.parse_args(args=sys.argv[1:])


def to_string(b):
    """Return the parameter as type 'str', possibly encoding it.

    In Python2, the 'str' type is the same as 'bytes'. In Python3, the
    'str' type is (essentially) Python2's 'unicode' type, and 'bytes' is
    distinct.

    This function is copied from llvm/utils/lit/lit/util.py
    """
    if isinstance(b, str):
        # In Python2, this branch is taken for types 'str' and 'bytes'.
        # In Python3, this branch is taken only for 'str'.
        return b
    if isinstance(b, bytes):
        # In Python2, this branch is never taken ('bytes' is handled as 'str').
        # In Python3, this is true only for 'bytes'.
        try:
            return b.decode("utf-8")
        except UnicodeDecodeError:
            # If the value is not valid Unicode, return the default
            # repr-line encoding.
            return str(b)

    # By this point, here's what we *don't* have:
    #
    #  - In Python2:
    #    - 'str' or 'bytes' (1st branch above)
    #  - In Python3:
    #    - 'str' (1st branch above)
    #    - 'bytes' (2nd branch above)
    #
    # The last type we might expect is the Python2 'unicode' type. There is no
    # 'unicode' type in Python3 (all the Python3 cases were already handled). In
    # order to get a 'str' object, we need to encode the 'unicode' object.
    try:
        return b.encode("utf-8")
    except AttributeError:
        raise TypeError("not sure how to convert %s to %s" % (type(b), str))


def format_text(lines, indent_0, indent_n):
    result = " " * indent_0 + lines[0]
    for next in lines[1:]:
        result = result + "\n{0}{1}".format(" " * indent_n, next)
    return result


def print_environment(env):
    if env is None:
        print("    Inherited")
        return
    for e in env:
        value = env[e]
        lines = value.split(os.pathsep)
        formatted_value = format_text(lines, 0, 7 + len(e))
        print("    {0} = {1}".format(e, formatted_value))


def find_executable(binary_name, search_paths):
    # shutil.which will ignore PATH if given a path argument, we want to include it.
    search_paths.append(os.environ.get("PATH", ""))
    search_path = os.pathsep.join(search_paths)
    binary_path = shutil.which(binary_name, path=search_path)
    if binary_path is not None:
        # So for example, we get '/bin/gcc' instead of '/usr/../bin/gcc'.
        binary_path = os.path.normpath(binary_path)
    return binary_path


def find_toolchain(compiler, tools_dir):
    if compiler == "msvc":
        return ("msvc", find_executable("cl", tools_dir))
    if compiler == "clang-cl":
        return ("clang-cl", find_executable("clang-cl", tools_dir))
    if compiler == "gcc":
        return ("gcc", find_executable("g++", tools_dir))
    if compiler == "clang":
        return ("clang", find_executable("clang++", tools_dir))
    if compiler == "any":
        priorities = []
        if sys.platform == "win32":
            priorities = ["clang-cl", "msvc", "clang", "gcc"]
        else:
            priorities = ["clang", "gcc", "clang-cl"]
        for toolchain in priorities:
            (type, dir) = find_toolchain(toolchain, tools_dir)
            if type and dir:
                return (type, dir)
        # Could not find any toolchain.
        return (None, None)

    # From here on, assume that |compiler| is a path to a file.
    file = os.path.basename(compiler)
    name, ext = os.path.splitext(file)
    if file.lower() == "cl.exe":
        return ("msvc", compiler)
    if name == "clang-cl":
        return ("clang-cl", compiler)
    if name.startswith("clang"):
        return ("clang", compiler)
    if name.startswith("gcc") or name.startswith("g++"):
        return ("gcc", compiler)
    if name == "cc" or name == "c++":
        return ("generic", compiler)
    return ("unknown", compiler)


class Builder(object):
    def __init__(self, toolchain_type, args, obj_ext):
        self.toolchain_type = toolchain_type
        self.inputs = args.inputs
        self.arch = args.arch
        self.opt = args.opt
        self.outdir = args.outdir
        self.compiler = args.compiler
        self.clean = args.clean
        self.output = args.output
        self.mode = args.mode
        self.nodefaultlib = args.nodefaultlib
        self.verbose = args.verbose
        self.obj_ext = obj_ext
        self.lib_paths = args.libs_dir
        self.std = args.std
        assert (
            not args.objc_gnustep or args.objc_gnustep_dir
        ), "--objc-gnustep specified without path to libobjc2"
        self.objc_gnustep_inc = (
            os.path.join(args.objc_gnustep_dir, "include")
            if args.objc_gnustep_dir
            else None
        )
        self.objc_gnustep_lib = (
            os.path.join(args.objc_gnustep_dir, "lib")
            if args.objc_gnustep_dir
            else None
        )
        self.sysroot = args.sysroot

    def _exe_file_name(self):
        assert self.mode != "compile"
        return self.output

    def _output_name(self, input, extension, with_executable=False):
        basename = os.path.splitext(os.path.basename(input))[0] + extension
        if with_executable:
            exe_basename = os.path.basename(self._exe_file_name())
            basename = exe_basename + "-" + basename

        output = os.path.join(self.outdir, basename)
        return os.path.normpath(output)

    def _obj_file_names(self):
        if self.mode == "link":
            return self.inputs

        if self.mode == "compile-and-link":
            # Object file names should factor in both the input file (source)
            # name and output file (executable) name, to ensure that two tests
            # which share a common source file don't race to write the same
            # object file.
            return [self._output_name(x, self.obj_ext, True) for x in self.inputs]

        if self.mode == "compile" and self.output:
            return [self.output]

        return [self._output_name(x, self.obj_ext) for x in self.inputs]

    def build_commands(self):
        commands = []
        if self.mode == "compile" or self.mode == "compile-and-link":
            for input, output in zip(self.inputs, self._obj_file_names()):
                commands.append(self._get_compilation_command(input, output))
        if self.mode == "link" or self.mode == "compile-and-link":
            commands.append(self._get_link_command())
        return commands


class MsvcBuilder(Builder):
    def __init__(self, toolchain_type, args):
        Builder.__init__(self, toolchain_type, args, ".obj")

        if platform.uname().machine.lower() == "arm64":
            self.msvc_arch_str = "arm" if self.arch == "32" else "arm64"
        else:
            self.msvc_arch_str = "x86" if self.arch == "32" else "x64"

        if toolchain_type == "msvc":
            # Make sure we're using the appropriate toolchain for the desired
            # target type.
            compiler_parent_dir = os.path.dirname(self.compiler)
            selected_target_version = os.path.basename(compiler_parent_dir)
            if selected_target_version != self.msvc_arch_str:
                host_dir = os.path.dirname(compiler_parent_dir)
                self.compiler = os.path.join(host_dir, self.msvc_arch_str, "cl.exe")
                if self.verbose:
                    print(
                        'Using alternate compiler "{0}" to match selected target.'.format(
                            self.compiler
                        )
                    )

        if self.mode == "link" or self.mode == "compile-and-link":
            self.linker = (
                self._find_linker("link")
                if toolchain_type == "msvc"
                else self._find_linker("lld-link", args.tools_dir)
            )
            if not self.linker:
                raise ValueError("Unable to find an appropriate linker.")

        self.compile_env, self.link_env = self._get_visual_studio_environment()

    def _find_linker(self, name, search_paths=[]):
        compiler_dir = os.path.dirname(self.compiler)
        linker_path = find_executable(name, [compiler_dir] + search_paths)
        if linker_path is None:
            raise ValueError("Could not find '{}'".format(name))
        return linker_path

    def _get_vc_install_dir(self):
        dir = os.getenv("VCINSTALLDIR", None)
        if dir:
            if self.verbose:
                print("Using %VCINSTALLDIR% {}".format(dir))
            return dir

        dir = os.getenv("VSINSTALLDIR", None)
        if dir:
            if self.verbose:
                print("Using %VSINSTALLDIR% {}".format(dir))
            return os.path.join(dir, "VC")

        dir = os.getenv("VS2019INSTALLDIR", None)
        if dir:
            if self.verbose:
                print("Using %VS2019INSTALLDIR% {}".format(dir))
            return os.path.join(dir, "VC")

        dir = os.getenv("VS2017INSTALLDIR", None)
        if dir:
            if self.verbose:
                print("Using %VS2017INSTALLDIR% {}".format(dir))
            return os.path.join(dir, "VC")

        dir = os.getenv("VS2015INSTALLDIR", None)
        if dir:
            if self.verbose:
                print("Using %VS2015INSTALLDIR% {}".format(dir))
            return os.path.join(dir, "VC")
        return None

    def _get_vctools_version(self):
        ver = os.getenv("VCToolsVersion", None)
        if ver:
            if self.verbose:
                print("Using %VCToolsVersion% {}".format(ver))
            return ver

        vcinstalldir = self._get_vc_install_dir()
        vcinstalldir = os.path.join(vcinstalldir, "Tools", "MSVC")
        subdirs = next(os.walk(vcinstalldir))[1]
        if not subdirs:
            return None

        from distutils.version import StrictVersion

        subdirs.sort(key=lambda x: StrictVersion(x))

        if self.verbose:
            full_path = os.path.join(vcinstalldir, subdirs[-1])
            print(
                "Using VC tools version directory {0} found by directory walk.".format(
                    full_path
                )
            )
        return subdirs[-1]

    def _get_vctools_install_dir(self):
        dir = os.getenv("VCToolsInstallDir", None)
        if dir:
            if self.verbose:
                print("Using %VCToolsInstallDir% {}".format(dir))
            return dir

        vcinstalldir = self._get_vc_install_dir()
        if not vcinstalldir:
            return None
        vctoolsver = self._get_vctools_version()
        if not vctoolsver:
            return None
        result = os.path.join(vcinstalldir, "Tools", "MSVC", vctoolsver)
        if not os.path.exists(result):
            return None
        if self.verbose:
            print(
                "Using VC tools install dir {} found by directory walk".format(result)
            )
        return result

    def _find_windows_sdk_in_registry_view(self, view):
        products_key = None
        roots_key = None
        installed_options_keys = []
        try:
            sam = view | winreg.KEY_READ
            products_key = winreg.OpenKey(
                winreg.HKEY_LOCAL_MACHINE,
                r"Software\Microsoft\Windows Kits\Installed Products",
                0,
                sam,
            )

            # This is the GUID for the desktop component.  If this is present
            # then the components required for the Desktop SDK are installed.
            # If not it will throw an exception.
            winreg.QueryValueEx(products_key, "{5A3D81EC-D870-9ECF-D997-24BDA6644752}")

            roots_key = winreg.OpenKey(
                winreg.HKEY_LOCAL_MACHINE,
                r"Software\Microsoft\Windows Kits\Installed Roots",
                0,
                sam,
            )
            root_dir = winreg.QueryValueEx(roots_key, "KitsRoot10")
            root_dir = to_string(root_dir[0])
            sdk_versions = []
            index = 0
            while True:
                # Installed SDK versions are stored as sub-keys of the
                # 'Installed Roots' key.  Find all of their names, then sort
                # them by version
                try:
                    ver_key = winreg.EnumKey(roots_key, index)
                    sdk_versions.append(ver_key)
                    index = index + 1
                except WindowsError:
                    break
            if not sdk_versions:
                return (None, None)

            # Windows SDK version numbers consist of 4 dotted components, so we
            # have to use LooseVersion, as StrictVersion supports 3 or fewer.
            from pkg_resources import packaging

            sdk_versions.sort(key=lambda x: packaging.version.parse(x), reverse=True)
            option_value_name = "OptionId.DesktopCPP" + self.msvc_arch_str
            for v in sdk_versions:
                try:
                    version_subkey = v + r"\Installed Options"
                    key = winreg.OpenKey(roots_key, version_subkey)
                    installed_options_keys.append(key)
                    (value, value_type) = winreg.QueryValueEx(key, option_value_name)
                    if value == 1:
                        # The proper architecture is installed.  Return the
                        # associated paths.
                        if self.verbose:
                            print(
                                "Found Installed Windows SDK v{0} at {1}".format(
                                    v, root_dir
                                )
                            )
                        return (root_dir, v)
                except:
                    continue
        except:
            return (None, None)
        finally:
            del products_key
            del roots_key
            for k in installed_options_keys:
                del k
        return (None, None)

    def _find_windows_sdk_in_registry(self):
        # This could be a clang-cl cross-compile.  If so, there's no registry
        # so just exit.
        if sys.platform != "win32":
            return (None, None)
        if self.verbose:
            print("Looking for Windows SDK in 64-bit registry.")
        dir, ver = self._find_windows_sdk_in_registry_view(winreg.KEY_WOW64_64KEY)
        if not dir or not ver:
            if self.verbose:
                print("Looking for Windows SDK in 32-bit registry.")
            dir, ver = self._find_windows_sdk_in_registry_view(winreg.KEY_WOW64_32KEY)

        return (dir, ver)

    def _get_winsdk_dir(self):
        # If a Windows SDK is specified in the environment, use that.  Otherwise
        # try to find one in the Windows registry.
        dir = os.getenv("WindowsSdkDir", None)
        if not dir or not os.path.exists(dir):
            return self._find_windows_sdk_in_registry()
        ver = os.getenv("WindowsSDKLibVersion", None)
        if not ver:
            return self._find_windows_sdk_in_registry()

        ver = ver.rstrip("\\")
        if self.verbose:
            print("Using %WindowsSdkDir% {}".format(dir))
            print("Using %WindowsSDKLibVersion% {}".format(ver))
        return (dir, ver)

    def _get_msvc_native_toolchain_dir(self):
        assert self.toolchain_type == "msvc"
        compiler_dir = os.path.dirname(self.compiler)
        target_dir = os.path.dirname(compiler_dir)
        host_name = os.path.basename(target_dir)
        host_name = host_name[4:].lower()
        return os.path.join(target_dir, host_name)

    def _get_visual_studio_environment(self):
        vctools = self._get_vctools_install_dir()
        winsdk, winsdkver = self._get_winsdk_dir()

        if not vctools and self.verbose:
            print("Unable to find VC tools installation directory.")
        if (not winsdk or not winsdkver) and self.verbose:
            print("Unable to find Windows SDK directory.")

        vcincludes = []
        vclibs = []
        sdkincludes = []
        sdklibs = []
        if vctools is not None:
            includes = [["ATLMFC", "include"], ["include"]]
            libs = [["ATLMFC", "lib"], ["lib"]]
            vcincludes = [os.path.join(vctools, *y) for y in includes]
            vclibs = [os.path.join(vctools, *y) for y in libs]
        if winsdk is not None:
            includes = [
                ["include", winsdkver, "ucrt"],
                ["include", winsdkver, "shared"],
                ["include", winsdkver, "um"],
                ["include", winsdkver, "winrt"],
                ["include", winsdkver, "cppwinrt"],
            ]
            libs = [["lib", winsdkver, "ucrt"], ["lib", winsdkver, "um"]]
            sdkincludes = [os.path.join(winsdk, *y) for y in includes]
            sdklibs = [os.path.join(winsdk, *y) for y in libs]

        includes = vcincludes + sdkincludes
        libs = vclibs + sdklibs
        libs = [os.path.join(x, self.msvc_arch_str) for x in libs]
        compileenv = None
        linkenv = None
        defaultenv = {}
        if sys.platform == "win32":
            defaultenv = {
                x: os.environ[x] for x in ["SystemDrive", "SystemRoot", "TMP", "TEMP"]
            }
            # The directory to mspdbcore.dll needs to be in PATH, but this is
            # always in the native toolchain path, not the cross-toolchain
            # path.  So, for example, if we're using HostX64\x86 then we need
            # to add HostX64\x64 to the path, and if we're using HostX86\x64
            # then we need to add HostX86\x86 to the path.
            if self.toolchain_type == "msvc":
                defaultenv["PATH"] = self._get_msvc_native_toolchain_dir()

        if includes:
            compileenv = {}
            compileenv["INCLUDE"] = os.pathsep.join(includes)
            compileenv.update(defaultenv)
        if libs:
            linkenv = {}
            linkenv["LIB"] = os.pathsep.join(libs)
            linkenv.update(defaultenv)
        return (compileenv, linkenv)

    def _ilk_file_names(self):
        if self.mode == "link":
            return []

        return [self._output_name(x, ".ilk") for x in self.inputs]

    def _pdb_file_name(self):
        if self.mode == "compile":
            return None
        return os.path.splitext(self.output)[0] + ".pdb"

    def _get_compilation_command(self, source, obj):
        args = []

        args.append(self.compiler)
        if self.toolchain_type == "clang-cl":
            args.append("-m" + self.arch)

        if self.opt == "none":
            args.append("/Od")
        elif self.opt == "basic":
            args.append("/O2")
        elif self.opt == "lto":
            if self.toolchain_type == "msvc":
                args.append("/GL")
                args.append("/Gw")
            else:
                args.append("-flto=thin")
        if self.nodefaultlib:
            args.append("/GS-")
            args.append("/GR-")
        args.append("/Z7")
        if self.toolchain_type == "clang-cl":
            args.append("-Xclang")
            args.append("-fkeep-static-consts")
            args.append("-fms-compatibility-version=19")
        args.append("/c")

        args.append("/Fo" + obj)
        if self.toolchain_type == "clang-cl":
            args.append("--")
        args.append(source)

        if self.std:
            args.append("/std:" + self.std)

        return ("compiling", [source], obj, self.compile_env, args)

    def _get_link_command(self):
        args = []
        args.append(self.linker)
        args.append("/DEBUG:FULL")
        args.append("/INCREMENTAL:NO")
        if self.nodefaultlib:
            args.append("/nodefaultlib")
            args.append("/entry:main")
        args.append("/PDB:" + self._pdb_file_name())
        args.append("/OUT:" + self._exe_file_name())
        args.extend(self._obj_file_names())

        return (
            "linking",
            self._obj_file_names(),
            self._exe_file_name(),
            self.link_env,
            args,
        )

    def build_commands(self):
        commands = []
        if self.mode == "compile" or self.mode == "compile-and-link":
            for input, output in zip(self.inputs, self._obj_file_names()):
                commands.append(self._get_compilation_command(input, output))
        if self.mode == "link" or self.mode == "compile-and-link":
            commands.append(self._get_link_command())
        return commands

    def output_files(self):
        outputs = []
        if self.mode == "compile" or self.mode == "compile-and-link":
            outputs.extend(self._ilk_file_names())
            outputs.extend(self._obj_file_names())
        if self.mode == "link" or self.mode == "compile-and-link":
            outputs.append(self._pdb_file_name())
            outputs.append(self._exe_file_name())

        return [x for x in outputs if x is not None]


class GccBuilder(Builder):
    def __init__(self, toolchain_type, args):
        Builder.__init__(self, toolchain_type, args, ".o")
        if sys.platform == "darwin":
            cmd = ["xcrun", "--sdk", args.apple_sdk, "--show-sdk-path"]
            self.apple_sdk = subprocess.check_output(cmd).strip().decode("utf-8")

    def _get_compilation_command(self, source, obj):
        args = []

        args.append(self.compiler)
        args.append("-m" + self.arch)

        args.append("-g")
        if self.opt == "none":
            args.append("-O0")
        elif self.opt == "basic":
            args.append("-O2")
        elif self.opt == "lto":
            args.append("-flto=thin")
        if self.nodefaultlib:
            args.append("-nostdinc")
            args.append("-static")
        args.append("-c")

        if sys.platform == "darwin":
            args.extend(["-isysroot", self.apple_sdk])
        elif self.objc_gnustep_inc:
            if source.endswith(".m") or source.endswith(".mm"):
                args.extend(["-fobjc-runtime=gnustep-2.0", "-I", self.objc_gnustep_inc])
                if sys.platform == "win32":
                    args.extend(
                        ["-Xclang", "-gcodeview", "-Xclang", "--dependent-lib=msvcrtd"]
                    )
        elif self.sysroot:
            args.extend(["--sysroot", self.sysroot])

        if self.std:
            args.append("-std={0}".format(self.std))

        args.extend(["-o", obj])
        args.append(source)

        return ("compiling", [source], obj, None, args)

    def _get_link_command(self):
        args = []
        args.append(self.compiler)
        args.append("-m" + self.arch)
        if self.nodefaultlib:
            args.append("-nostdlib")
            args.append("-static")
            main_symbol = "main"
            if sys.platform == "darwin":
                main_symbol = "_main"
            args.append("-Wl,-e," + main_symbol)
        if sys.platform.startswith("netbsd"):
            for x in self.lib_paths:
                args += ["-L" + x, "-Wl,-rpath," + x]
        args.extend(["-o", self._exe_file_name()])
        args.extend(self._obj_file_names())

        if sys.platform == "darwin":
            args.extend(["-isysroot", self.apple_sdk])
        elif self.objc_gnustep_lib:
            args.extend(["-L", self.objc_gnustep_lib, "-lobjc"])
            if sys.platform == "linux":
                args.extend(["-Wl,-rpath," + self.objc_gnustep_lib])
            elif sys.platform == "win32":
                args.extend(
                    ["-fuse-ld=lld-link", "-g", "-Xclang", "--dependent-lib=msvcrtd"]
                )
        elif self.sysroot:
            args.extend(["--sysroot", self.sysroot])

        return ("linking", self._obj_file_names(), self._exe_file_name(), None, args)

    def output_files(self):
        outputs = []
        if self.mode == "compile" or self.mode == "compile-and-link":
            outputs.extend(self._obj_file_names())
        if self.mode == "link" or self.mode == "compile-and-link":
            outputs.append(self._exe_file_name())

        return outputs


def indent(text, spaces):
    def prefixed_lines():
        prefix = " " * spaces
        for line in text.splitlines(True):
            yield prefix + line

    return "".join(prefixed_lines())


def build(commands):
    global args
    for status, inputs, output, env, child_args in commands:
        print("\n\n")
        inputs = [os.path.basename(x) for x in inputs]
        output = os.path.basename(output)
        print(status + " {0} -> {1}".format("+".join(inputs), output))

        if args.verbose:
            print("  Command Line: " + " ".join(child_args))
            print("  Env:")
            print_environment(env)
        if args.dry:
            continue

        popen = subprocess.Popen(
            child_args,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            env=env,
            universal_newlines=True,
        )
        stdout, stderr = popen.communicate()
        res = popen.wait()
        if res == -signal.SIGINT:
            raise KeyboardInterrupt
        print("  STDOUT:")
        print(indent(stdout, 4))
        if res != 0:
            print("  STDERR:")
            print(indent(stderr, 4))
            sys.exit(res)


def clean(files):
    global args
    if not files:
        return
    for o in files:
        file = o if args.verbose else os.path.basename(o)
        print("Cleaning {0}".format(file))
        try:
            if os.path.exists(o):
                if not args.dry:
                    os.remove(o)
                if args.verbose:
                    print("  The file was successfully cleaned.")
            elif args.verbose:
                print("  The file does not exist.")
        except:
            if args.verbose:
                print("  The file could not be removed.")


def fix_arguments(args):
    if not args.inputs:
        raise ValueError("No input files specified")

    if args.output and args.mode == "compile" and len(args.inputs) > 1:
        raise ValueError(
            "Cannot specify -o with mode=compile and multiple source files.  Use --outdir instead."
        )

    if not args.dry:
        args.inputs = [os.path.abspath(x) for x in args.inputs]

    # If user didn't specify the outdir, use the directory of the first input.
    if not args.outdir:
        if args.output:
            args.outdir = os.path.dirname(args.output)
        else:
            args.outdir = os.path.dirname(args.inputs[0])
            args.outdir = os.path.abspath(args.outdir)
        args.outdir = os.path.normpath(args.outdir)

    # If user specified a non-absolute path for the output file, append the
    # output directory to it.
    if args.output:
        if not os.path.isabs(args.output):
            args.output = os.path.join(args.outdir, args.output)
        args.output = os.path.normpath(args.output)


fix_arguments(args)

(toolchain_type, toolchain_path) = find_toolchain(args.compiler, args.tools_dir)
if not toolchain_path or not toolchain_type:
    print("Unable to find toolchain {0}".format(args.compiler))
    sys.exit(1)

if args.verbose:
    print("Script Arguments:")
    print("  Arch: " + args.arch)
    print("  Compiler: " + args.compiler)
    print("  Outdir: " + args.outdir)
    print("  Output: " + args.output)
    print("  Nodefaultlib: " + str(args.nodefaultlib))
    print("  Opt: " + args.opt)
    print("  Mode: " + args.mode)
    print("  Clean: " + str(args.clean))
    print("  Verbose: " + str(args.verbose))
    print("  Dryrun: " + str(args.dry))
    print("  Inputs: " + format_text(args.inputs, 0, 10))
    print("  C/C++ Standard: " + str(args.std))
    print("Script Environment:")
    print_environment(os.environ)

args.compiler = toolchain_path
if not os.path.exists(args.compiler) and not args.dry:
    raise ValueError("The toolchain {} does not exist.".format(args.compiler))

if toolchain_type == "msvc" or toolchain_type == "clang-cl":
    builder = MsvcBuilder(toolchain_type, args)
else:
    builder = GccBuilder(toolchain_type, args)

if args.clean:
    clean(builder.output_files())

cmds = builder.build_commands()

build(cmds)