#!/usr/bin/env python

# ignore-tidy-linelength

from __future__ import absolute_import, division, print_function
import shlex
import sys
import os
import re

rust_dir = os.path.dirname(os.path.abspath(__file__))
rust_dir = os.path.dirname(rust_dir)
rust_dir = os.path.dirname(rust_dir)
sys.path.append(os.path.join(rust_dir, "src", "bootstrap"))
import bootstrap  # noqa: E402


class Option(object):
    def __init__(self, name, rustbuild, desc, value):
        self.name = name
        self.rustbuild = rustbuild
        self.desc = desc
        self.value = value


options = []


def o(*args):
    options.append(Option(*args, value=False))


def v(*args):
    options.append(Option(*args, value=True))


o(
    "debug",
    "rust.debug",
    "enables debugging environment; does not affect optimization of bootstrapped code",
)
o("docs", "build.docs", "build standard library documentation")
o("compiler-docs", "build.compiler-docs", "build compiler documentation")
o("optimize-tests", "rust.optimize-tests", "build tests with optimizations")
o("verbose-tests", "rust.verbose-tests", "enable verbose output when running tests")
o(
    "ccache",
    "build.ccache",
    "invoke gcc/clang/rustc via ccache to reuse object files between builds",
)
o(
    "sccache",
    None,
    "invoke gcc/clang/rustc via sccache to reuse object files between builds",
)
o("local-rust", None, "use an installed rustc rather than downloading a snapshot")
v("local-rust-root", None, "set prefix for local rust binary")
o(
    "local-rebuild",
    "build.local-rebuild",
    "assume local-rust matches the current version, for rebuilds; implies local-rust, and is implied if local-rust already matches the current version",
)
o(
    "llvm-static-stdcpp",
    "llvm.static-libstdcpp",
    "statically link to libstdc++ for LLVM",
)
o(
    "llvm-link-shared",
    "llvm.link-shared",
    "prefer shared linking to LLVM (llvm-config --link-shared)",
)
o("rpath", "rust.rpath", "build rpaths into rustc itself")
o("codegen-tests", "rust.codegen-tests", "run the tests/codegen tests")
o(
    "ninja",
    "llvm.ninja",
    "build LLVM using the Ninja generator (for MSVC, requires building in the correct environment)",
)
o("locked-deps", "build.locked-deps", "force Cargo.lock to be up to date")
o("vendor", "build.vendor", "enable usage of vendored Rust crates")
o(
    "sanitizers",
    "build.sanitizers",
    "build the sanitizer runtimes (asan, dfsan, lsan, msan, tsan, hwasan)",
)
o(
    "dist-src",
    "rust.dist-src",
    "when building tarballs enables building a source tarball",
)
o(
    "cargo-native-static",
    "build.cargo-native-static",
    "static native libraries in cargo",
)
o("profiler", "build.profiler", "build the profiler runtime")
o("full-tools", None, "enable all tools")
o("lld", "rust.lld", "build lld")
o("llvm-bitcode-linker", "rust.llvm-bitcode-linker", "build llvm bitcode linker")
o("clang", "llvm.clang", "build clang")
o("use-libcxx", "llvm.use-libcxx", "build LLVM with libc++")
o("control-flow-guard", "rust.control-flow-guard", "Enable Control Flow Guard")
o(
    "patch-binaries-for-nix",
    "build.patch-binaries-for-nix",
    "whether patch binaries for usage with Nix toolchains",
)
o("new-symbol-mangling", "rust.new-symbol-mangling", "use symbol-mangling-version v0")

v("llvm-cflags", "llvm.cflags", "build LLVM with these extra compiler flags")
v("llvm-cxxflags", "llvm.cxxflags", "build LLVM with these extra compiler flags")
v("llvm-ldflags", "llvm.ldflags", "build LLVM with these extra linker flags")

v("llvm-libunwind", "rust.llvm-libunwind", "use LLVM libunwind")

# Optimization and debugging options. These may be overridden by the release
# channel, etc.
o("optimize-llvm", "llvm.optimize", "build optimized LLVM")
o("llvm-assertions", "llvm.assertions", "build LLVM with assertions")
o("llvm-enzyme", "llvm.enzyme", "build LLVM with enzyme")
o("llvm-offload", "llvm.offload", "build LLVM with gpu offload support")
o("llvm-plugins", "llvm.plugins", "build LLVM with plugin interface")
o("debug-assertions", "rust.debug-assertions", "build with debugging assertions")
o(
    "debug-assertions-std",
    "rust.debug-assertions-std",
    "build the standard library with debugging assertions",
)
o("overflow-checks", "rust.overflow-checks", "build with overflow checks")
o(
    "overflow-checks-std",
    "rust.overflow-checks-std",
    "build the standard library with overflow checks",
)
o(
    "llvm-release-debuginfo",
    "llvm.release-debuginfo",
    "build LLVM with debugger metadata",
)
v("debuginfo-level", "rust.debuginfo-level", "debuginfo level for Rust code")
v(
    "debuginfo-level-rustc",
    "rust.debuginfo-level-rustc",
    "debuginfo level for the compiler",
)
v(
    "debuginfo-level-std",
    "rust.debuginfo-level-std",
    "debuginfo level for the standard library",
)
v(
    "debuginfo-level-tools",
    "rust.debuginfo-level-tools",
    "debuginfo level for the tools",
)
v(
    "debuginfo-level-tests",
    "rust.debuginfo-level-tests",
    "debuginfo level for the test suites run with compiletest",
)
v(
    "save-toolstates",
    "rust.save-toolstates",
    "save build and test status of external tools into this file",
)

v("prefix", "install.prefix", "set installation prefix")
v("localstatedir", "install.localstatedir", "local state directory")
v("datadir", "install.datadir", "install data")
v("sysconfdir", "install.sysconfdir", "install system configuration files")
v("infodir", "install.infodir", "install additional info")
v("libdir", "install.libdir", "install libraries")
v("mandir", "install.mandir", "install man pages in PATH")
v("docdir", "install.docdir", "install documentation in PATH")
v("bindir", "install.bindir", "install binaries")

v("llvm-root", None, "set LLVM root")
v("llvm-config", None, "set path to llvm-config")
v("llvm-filecheck", None, "set path to LLVM's FileCheck utility")
v("python", "build.python", "set path to python")
v("android-ndk", "build.android-ndk", "set path to Android NDK")
v(
    "musl-root",
    "target.x86_64-unknown-linux-musl.musl-root",
    "MUSL root installation directory (deprecated)",
)
v(
    "musl-root-x86_64",
    "target.x86_64-unknown-linux-musl.musl-root",
    "x86_64-unknown-linux-musl install directory",
)
v(
    "musl-root-i586",
    "target.i586-unknown-linux-musl.musl-root",
    "i586-unknown-linux-musl install directory",
)
v(
    "musl-root-i686",
    "target.i686-unknown-linux-musl.musl-root",
    "i686-unknown-linux-musl install directory",
)
v(
    "musl-root-arm",
    "target.arm-unknown-linux-musleabi.musl-root",
    "arm-unknown-linux-musleabi install directory",
)
v(
    "musl-root-armhf",
    "target.arm-unknown-linux-musleabihf.musl-root",
    "arm-unknown-linux-musleabihf install directory",
)
v(
    "musl-root-armv5te",
    "target.armv5te-unknown-linux-musleabi.musl-root",
    "armv5te-unknown-linux-musleabi install directory",
)
v(
    "musl-root-armv7",
    "target.armv7-unknown-linux-musleabi.musl-root",
    "armv7-unknown-linux-musleabi install directory",
)
v(
    "musl-root-armv7hf",
    "target.armv7-unknown-linux-musleabihf.musl-root",
    "armv7-unknown-linux-musleabihf install directory",
)
v(
    "musl-root-aarch64",
    "target.aarch64-unknown-linux-musl.musl-root",
    "aarch64-unknown-linux-musl install directory",
)
v(
    "musl-root-mips",
    "target.mips-unknown-linux-musl.musl-root",
    "mips-unknown-linux-musl install directory",
)
v(
    "musl-root-mipsel",
    "target.mipsel-unknown-linux-musl.musl-root",
    "mipsel-unknown-linux-musl install directory",
)
v(
    "musl-root-mips64",
    "target.mips64-unknown-linux-muslabi64.musl-root",
    "mips64-unknown-linux-muslabi64 install directory",
)
v(
    "musl-root-mips64el",
    "target.mips64el-unknown-linux-muslabi64.musl-root",
    "mips64el-unknown-linux-muslabi64 install directory",
)
v(
    "musl-root-powerpc64",
    "target.powerpc64-unknown-linux-musl.musl-root",
    "powerpc64-unknown-linux-musl install directory",
)
v(
    "musl-root-powerpc64le",
    "target.powerpc64le-unknown-linux-musl.musl-root",
    "powerpc64le-unknown-linux-musl install directory",
)
v(
    "musl-root-riscv32gc",
    "target.riscv32gc-unknown-linux-musl.musl-root",
    "riscv32gc-unknown-linux-musl install directory",
)
v(
    "musl-root-riscv64gc",
    "target.riscv64gc-unknown-linux-musl.musl-root",
    "riscv64gc-unknown-linux-musl install directory",
)
v(
    "musl-root-loongarch64",
    "target.loongarch64-unknown-linux-musl.musl-root",
    "loongarch64-unknown-linux-musl install directory",
)
v(
    "musl-root-wali-wasm32",
    "target.wasm32-wali-linux-musl.musl-root",
    "wasm32-wali-linux-musl install directory",
)
v(
    "qemu-armhf-rootfs",
    "target.arm-unknown-linux-gnueabihf.qemu-rootfs",
    "rootfs in qemu testing, you probably don't want to use this",
)
v(
    "qemu-aarch64-rootfs",
    "target.aarch64-unknown-linux-gnu.qemu-rootfs",
    "rootfs in qemu testing, you probably don't want to use this",
)
v(
    "qemu-riscv64-rootfs",
    "target.riscv64gc-unknown-linux-gnu.qemu-rootfs",
    "rootfs in qemu testing, you probably don't want to use this",
)
v(
    "experimental-targets",
    "llvm.experimental-targets",
    "experimental LLVM targets to build",
)
v("release-channel", "rust.channel", "the name of the release channel to build")
v(
    "release-description",
    "build.description",
    "optional descriptive string for version output",
)
v("dist-compression-formats", None, "List of compression formats to use")

# Used on systems where "cc" is unavailable
v("default-linker", "rust.default-linker", "the default linker")

# Many of these are saved below during the "writing configuration" step
# (others are conditionally saved).
o("manage-submodules", "build.submodules", "let the build manage the git submodules")
o(
    "full-bootstrap",
    "build.full-bootstrap",
    "build three compilers instead of two (not recommended except for testing reproducible builds)",
)
o("extended", "build.extended", "build an extended rust tool set")

v("bootstrap-cache-path", None, "use provided path for the bootstrap cache")
v("tools", None, "List of extended tools will be installed")
v("codegen-backends", None, "List of codegen backends to build")
v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
v("host", None, "List of GNUs ./configure syntax LLVM host triples")
v("target", None, "List of GNUs ./configure syntax LLVM target triples")

# Options specific to this configure script
o(
    "option-checking",
    None,
    "complain about unrecognized options in this configure script",
)
o(
    "verbose-configure",
    None,
    "don't truncate options when printing them in this configure script",
)
v("set", None, "set arbitrary key/value pairs in TOML configuration")


def p(msg):
    print("configure: " + msg)


def err(msg):
    print("\nconfigure: ERROR: " + msg + "\n")
    sys.exit(1)


def is_value_list(key):
    for option in options:
        if option.name == key and option.desc.startswith("List of"):
            return True
    return False


if "--help" in sys.argv or "-h" in sys.argv:
    print("Usage: ./configure [options]")
    print("")
    print("Options")
    for option in options:
        if "android" in option.name:
            # no one needs to know about these obscure options
            continue
        if option.value:
            print("\t{:30} {}".format("--{}=VAL".format(option.name), option.desc))
        else:
            print("\t--enable-{:25} OR --disable-{}".format(option.name, option.name))
            print("\t\t" + option.desc)
    print("")
    print("This configure script is a thin configuration shim over the true")
    print("configuration system, `bootstrap.toml`. You can explore the comments")
    print("in `bootstrap.example.toml` next to this configure script to see")
    print("more information about what each option is. Additionally you can")
    print("pass `--set` as an argument to set arbitrary key/value pairs")
    print("in the TOML configuration if desired")
    print("")
    print("Also note that all options which take `--enable` can similarly")
    print("be passed with `--disable-foo` to forcibly disable the option")
    sys.exit(0)

VERBOSE = False


# Parse all command line arguments into one of these three lists, handling
# boolean and value-based options separately
def parse_args(args):
    unknown_args = []
    need_value_args = []
    known_args = {}

    i = 0
    while i < len(args):
        arg = args[i]
        i += 1
        if not arg.startswith("--"):
            unknown_args.append(arg)
            continue

        found = False
        for option in options:
            value = None
            if option.value:
                keyval = arg[2:].split("=", 1)
                key = keyval[0]
                if option.name != key:
                    continue

                if len(keyval) > 1:
                    value = keyval[1]
                elif i < len(args):
                    value = args[i]
                    i += 1
                else:
                    need_value_args.append(arg)
                    continue
            else:
                if arg[2:] == "enable-" + option.name:
                    value = True
                elif arg[2:] == "disable-" + option.name:
                    value = False
                else:
                    continue

            found = True
            if option.name not in known_args:
                known_args[option.name] = []
            known_args[option.name].append((option, value))
            break

        if not found:
            unknown_args.append(arg)

    # NOTE: here and a few other places, we use [-1] to apply the *last* value
    # passed.  But if option-checking is enabled, then the known_args loop will
    # also assert that options are only passed once.
    option_checking = (
        "option-checking" not in known_args or known_args["option-checking"][-1][1]
    )
    if option_checking:
        if len(unknown_args) > 0:
            err("Option '" + unknown_args[0] + "' is not recognized")
        if len(need_value_args) > 0:
            err("Option '{0}' needs a value ({0}=val)".format(need_value_args[0]))

    global VERBOSE
    VERBOSE = "verbose-configure" in known_args

    config = {}

    set("build.configure-args", args, config)
    apply_args(known_args, option_checking, config)
    return parse_example_config(known_args, config)


def build(known_args):
    if "build" in known_args:
        return known_args["build"][-1][1]
    return bootstrap.default_build_triple(verbose=False)


def set(key, value, config):
    if isinstance(value, list):
        # Remove empty values, which value.split(',') tends to generate and
        # replace single quotes for double quotes to ensure correct parsing.
        value = [v.replace("'", '"') for v in value if v]

    s = "{:20} := {}".format(key, value)
    if len(s) < 70 or VERBOSE:
        p(s)
    else:
        p(s[:70] + " ...")

    arr = config

    # Split `key` on periods using shell semantics.
    lexer = shlex.shlex(key, posix=True)
    lexer.whitespace = "."
    lexer.wordchars += "-"
    parts = list(lexer)

    for i, part in enumerate(parts):
        if i == len(parts) - 1:
            if is_value_list(part) and isinstance(value, str):
                value = value.split(",")
            arr[part] = value
        else:
            if part not in arr:
                arr[part] = {}
            arr = arr[part]


def apply_args(known_args, option_checking, config):
    for key in known_args:
        # The `set` option is special and can be passed a bunch of times
        if key == "set":
            for _option, value in known_args[key]:
                keyval = value.split("=", 1)
                if len(keyval) == 1 or keyval[1] == "true":
                    value = True
                elif keyval[1] == "false":
                    value = False
                else:
                    value = keyval[1]
                set(keyval[0], value, config)
            continue

        # Ensure each option is only passed once
        arr = known_args[key]
        if option_checking and len(arr) > 1:
            err("Option '{}' provided more than once".format(key))
        option, value = arr[-1]

        # If we have a clear avenue to set our value in rustbuild, do so
        if option.rustbuild is not None:
            set(option.rustbuild, value, config)
            continue

        # Otherwise we're a "special" option and need some extra handling, so do
        # that here.
        build_triple = build(known_args)

        if option.name == "sccache":
            set("build.ccache", "sccache", config)
        elif option.name == "local-rust":
            for path in os.environ["PATH"].split(os.pathsep):
                if os.path.exists(path + "/rustc"):
                    set("build.rustc", path + "/rustc", config)
                    break
            for path in os.environ["PATH"].split(os.pathsep):
                if os.path.exists(path + "/cargo"):
                    set("build.cargo", path + "/cargo", config)
                    break
        elif option.name == "local-rust-root":
            set("build.rustc", value + "/bin/rustc", config)
            set("build.cargo", value + "/bin/cargo", config)
        elif option.name == "llvm-root":
            set(
                "target.{}.llvm-config".format(build_triple),
                value + "/bin/llvm-config",
                config,
            )
        elif option.name == "llvm-config":
            set("target.{}.llvm-config".format(build_triple), value, config)
        elif option.name == "llvm-filecheck":
            set("target.{}.llvm-filecheck".format(build_triple), value, config)
        elif option.name == "tools":
            set("build.tools", value.split(","), config)
        elif option.name == "bootstrap-cache-path":
            set("build.bootstrap-cache-path", value, config)
        elif option.name == "codegen-backends":
            set("rust.codegen-backends", value.split(","), config)
        elif option.name == "host":
            set("build.host", value.split(","), config)
        elif option.name == "target":
            set("build.target", value.split(","), config)
        elif option.name == "full-tools":
            set("rust.codegen-backends", ["llvm"], config)
            set("rust.lld", True, config)
            set("rust.llvm-tools", True, config)
            set("rust.llvm-bitcode-linker", True, config)
            set("build.extended", True, config)
        elif option.name in ["option-checking", "verbose-configure"]:
            # this was handled above
            pass
        elif option.name == "dist-compression-formats":
            set("dist.compression-formats", value.split(","), config)
        else:
            raise RuntimeError("unhandled option {}".format(option.name))


# "Parse" the `bootstrap.example.toml` file into the various sections, and we'll
# use this as a template of a `bootstrap.toml` to write out which preserves
# all the various comments and whatnot.
#
# Note that the `target` section is handled separately as we'll duplicate it
# per configured target, so there's a bit of special handling for that here.
def parse_example_config(known_args, config):
    sections = {}
    cur_section = None
    sections[None] = []
    section_order = [None]
    targets = {}
    top_level_keys = []
    comment_lines = []

    with open(rust_dir + "/bootstrap.example.toml") as example_config:
        example_lines = example_config.read().split("\n")
    for line in example_lines:
        if line.count("=") >= 1 and not line.startswith("# "):
            key = line.split("=")[0]
            key = key.strip(" #")
            parts = key.split(".")
            if len(parts) > 1:
                cur_section = parts[0]
                if cur_section not in sections:
                    sections[cur_section] = ["[" + cur_section + "]"]
                    section_order.append(cur_section)
            elif cur_section is None:
                top_level_keys.append(key)
            # put the comment lines within the start of
            # a new section, not outside it.
            sections[cur_section] += comment_lines
            comment_lines = []
            # remove just the `section.` part from the line, if present.
            sections[cur_section].append(
                re.sub("(#?)([a-zA-Z_-]+\\.)?(.*)", "\\1\\3", line)
            )
        elif line.startswith("["):
            cur_section = line[1:-1]
            if cur_section.startswith("target"):
                cur_section = "target"
            elif "." in cur_section:
                raise RuntimeError(
                    "don't know how to deal with section: {}".format(cur_section)
                )
            sections[cur_section] = [line]
            section_order.append(cur_section)
        else:
            comment_lines.append(line)

    sections[cur_section] += comment_lines
    # Fill out the `targets` array by giving all configured targets a copy of the
    # `target` section we just loaded from the example config
    configured_targets = [build(known_args)]
    if "build" in config:
        if "host" in config["build"]:
            configured_targets += config["build"]["host"]
        if "target" in config["build"]:
            configured_targets += config["build"]["target"]
    if "target" in config:
        for target in config["target"]:
            configured_targets.append(target)
    for target in configured_targets:
        targets[target] = sections["target"][:]
        # For `.` to be valid TOML, it needs to be quoted. But `bootstrap.py` doesn't use a proper TOML parser and fails to parse the target.
        # Avoid using quotes unless it's necessary.
        targets[target][0] = targets[target][0].replace(
            "x86_64-unknown-linux-gnu",
            "'{}'".format(target) if "." in target else target,
        )

    if "profile" not in config:
        set("profile", "dist", config)
    configure_file(sections, top_level_keys, targets, config)
    return section_order, sections, targets


def is_number(value):
    try:
        float(value)
        return True
    except ValueError:
        return False


# Here we walk through the constructed configuration we have from the parsed
# command line arguments. We then apply each piece of configuration by
# basically just doing a `sed` to change the various configuration line to what
# we've got configure.
def to_toml(value):
    if isinstance(value, bool):
        if value:
            return "true"
        else:
            return "false"
    elif isinstance(value, list):
        return "[" + ", ".join(map(to_toml, value)) + "]"
    elif isinstance(value, str):
        # Don't put quotes around numeric values
        if is_number(value):
            return value
        else:
            return "'" + value + "'"
    elif isinstance(value, dict):
        return (
            "{"
            + ", ".join(
                map(
                    lambda a: "{} = {}".format(to_toml(a[0]), to_toml(a[1])),
                    value.items(),
                )
            )
            + "}"
        )
    else:
        raise RuntimeError("no toml")


def configure_section(lines, config):
    for key in config:
        value = config[key]
        found = False
        for i, line in enumerate(lines):
            if not line.startswith("#" + key + " = "):
                continue
            found = True
            lines[i] = "{} = {}".format(key, to_toml(value))
            break
        if not found:
            # These are used by rpm, but aren't accepted by x.py.
            # Give a warning that they're ignored, but not a hard error.
            if key in ["infodir", "localstatedir"]:
                print("WARNING: {} will be ignored".format(key))
            else:
                raise RuntimeError("failed to find config line for {}".format(key))


def configure_top_level_key(lines, top_level_key, value):
    for i, line in enumerate(lines):
        if line.startswith("#" + top_level_key + " = ") or line.startswith(
            top_level_key + " = "
        ):
            lines[i] = "{} = {}".format(top_level_key, to_toml(value))
            return

    raise RuntimeError("failed to find config line for {}".format(top_level_key))


# Modify `sections` to reflect the parsed arguments and example configs.
def configure_file(sections, top_level_keys, targets, config):
    for section_key, section_config in config.items():
        if section_key not in sections and section_key not in top_level_keys:
            raise RuntimeError(
                "config key {} not in sections or top_level_keys".format(section_key)
            )
        if section_key in top_level_keys:
            configure_top_level_key(sections[None], section_key, section_config)

        elif section_key == "target":
            for target in section_config:
                configure_section(targets[target], section_config[target])
        else:
            configure_section(sections[section_key], section_config)


def write_uncommented(target, f):
    """Writes each block in 'target' that is not composed entirely of comments to 'f'.

    A block is a sequence of non-empty lines separated by empty lines.
    """
    block = []

    def flush(last):
        # If the block is entirely made of comments, ignore it
        entire_block_comments = all(ln.startswith("#") or ln == "" for ln in block)
        if not entire_block_comments and len(block) > 0:
            for line in block:
                f.write(line + "\n")
            # Required to output a newline before the start of a new section
            if last:
                f.write("\n")
        block.clear()

    for line in target:
        block.append(line)
        if len(line) == 0:
            flush(last=False)

    flush(last=True)
    return f


def write_config_toml(writer, section_order, targets, sections):
    for section in section_order:
        if section == "target":
            for target in targets:
                writer = write_uncommented(targets[target], writer)
        else:
            writer = write_uncommented(sections[section], writer)


def quit_if_file_exists(file):
    if os.path.isfile(file):
        msg = "Existing '{}' detected. Exiting".format(file)

        # If the output object directory isn't empty, we can get these errors
        host_objdir = os.environ.get("OBJDIR_ON_HOST")
        if host_objdir is not None:
            msg += "\nIs objdir '{}' clean?".format(host_objdir)

        err(msg)


if __name__ == "__main__":
    # If 'bootstrap.toml' already exists, exit the script at this point
    quit_if_file_exists("bootstrap.toml")

    if "GITHUB_ACTIONS" in os.environ:
        print("::group::Configure the build")
    p("processing command line")
    # Parse all known arguments into a configuration structure that reflects the
    # TOML we're going to write out
    p("")
    section_order, sections, targets = parse_args(sys.argv[1:])

    # Now that we've built up our `bootstrap.toml`, write it all out in the same
    # order that we read it in.
    p("")
    p("writing `bootstrap.toml` in current directory")
    with bootstrap.output("bootstrap.toml") as f:
        write_config_toml(f, section_order, targets, sections)

    with bootstrap.output("Makefile") as f:
        contents = os.path.join(rust_dir, "src", "bootstrap", "mk", "Makefile.in")
        contents = open(contents).read()
        contents = contents.replace("$(CFG_SRC_DIR)", rust_dir + "/")
        contents = contents.replace("$(CFG_PYTHON)", sys.executable)
        f.write(contents)

    p("")
    p("run `{} {}/x.py --help`".format(os.path.basename(sys.executable), rust_dir))
    if "GITHUB_ACTIONS" in os.environ:
        print("::endgroup::")