// mcpp.plugins.toolset -- the resolved toolchain, translated for a foreign

// build system (L2 of the build-plugin architecture, mcpp#734).

//

// A plugin that drives vcpkg, CMake, Meson or make hands it the tools the

// program is built with, so that what it builds links with the program. The

// engine states the facts (mcpp 2026.9.28.3, protocol 14): each role's tool,

// the target ABI's native tools, the environment the engine runs them with,

// a path-free identity of the toolset, the Visual Studio instance it came

// from, and the C++ runtime contract. This module decides HOW those facts

// reach a foreign system, once for every plugin:

//

// instance An MSVC toolset from a Visual Studio instance (`msvc@system`)

// is used through that instance. The foreign system's own

// toolset loading stays in place, pointed at the instance mcpp

// resolved, so MSBuild is present and every kind of project

// builds.

// chain Any other toolset -- a managed MSVC toolset, and the clang

// toolsets of the other rows -- is named: absolute tool paths, the

// environment they run with, and the directories that go first

// on PATH. On the MSVC ABI without an instance no MSBuild exists.

// detected Nothing is named, and the foreign system finds its own

// toolset. `source::detected` asks for it (kept by

// `src/compat/detected_toolset.cppm` until 2027-03-28); `resolved`

// answers it on the Linux GCC row, whose payload driver is not a

// complete handover (see `resolve`).

//

// NONE OF THIS NAMES A FOREIGN SYSTEM. vcpkg's triplet and CMake's generator

// are written by the plugins that drive them (`mcpp.deps.vcpkg`,

// `mcpp.deps.cmake`); this module stops at the tools.

export module mcpp.plugins.toolset;

import std;

import mcpp;

import mcpp.plugins.compat.detected_toolset;

export namespace mcpp::plugins::toolset {

// Who chooses the tools: the engine's resolution (`resolved`), or the foreign

// system's own detection (`detected`, a compatibility behaviour).

enum class source { resolved, detected };

// Which compiler `resolved` hands over. `abi_native` is the target ABI's own

// compiler (`cl.exe` on the MSVC ABI whichever driver the row uses; the row's

// compiler elsewhere). `row` is the compiler the row itself runs, for example

// clang on an LLVM row that targets the MSVC ABI.

enum class compiler { abi_native, row };

// Embedded in each plugin's options.

struct choice {

source toolset = source::resolved;

compiler cc = compiler::abi_native;

};

enum class mechanism { instance, chain, detected };

inline std::string_view name(mechanism m) {

return m == mechanism::instance ? "instance" : m == mechanism::chain ? "chain" : "detected";

}

struct resolved_tools {

mechanism how = mechanism::detected;

std::string instance_dir; // `instance`: the Visual Studio instance

std::string toolset_version; // `instance`: e.g. 14.44.35207; also set under `chain` on the MSVC ABI

std::string instance_default; // `instance`: the version the instance selects by itself

// Absolute paths, forward slashes. `chain` sets `cc` and `cxx` always and

// the others where the row has them; `detected` sets `cc` and `cxx` only

// where detection cannot agree with the program (the Linux libc++ row).

std::string cc, cxx, ld, ar, rc, mt;

// `chain` on the MSVC ABI: the environment the tools run with, without

// PATH (INCLUDE, LIB, LIBPATH, ...).

std::vector<std::pair<std::string, std::string>> env;

// `chain`: the tools' own directories, in order, without duplicates: the

// PATH a foreign system needs for them.

std::vector<std::string> path_dirs;

std::string identity; // toolset_identity(): "msvc 14.44.35207; sdk 10.0.26100.0", "clang 22.1.8"

std::string crt; // msvc_crt_linkage(): "static", "dynamic", or empty off the MSVC ABI

bool msvc_abi = false;

// Why `resolved` answered `detected`: empty unless the resolved toolset

// cannot be handed over by its tools alone.

std::string reason;

};

inline bool msvc_abi() {

return std::string_view(mcpp::target_os()) == "windows"

&& std::string_view(mcpp::target_env()) == "msvc";

}

inline bool host_is_windows() {

return std::string_view(mcpp::host()).find("windows") != std::string_view::npos;

}

// `a;b` on a Windows host, `a:b` elsewhere.

inline char path_separator() { return host_is_windows() ? ';' : ':'; }

inline std::string forward(std::string_view p) {

std::string s(p);

for (std::size_t i = 0; i < s.size(); ++i) if (s[i] == '\\') s[i] = '/';

return s;

}

// The toolset version out of an identity "msvc 14.44.35207; sdk 10.0.26100.0".

inline std::string msvc_version_of(std::string_view identity) {

if (!identity.starts_with("msvc ")) return {};

identity.remove_prefix(5);

const auto end = identity.find(';');

return std::string(identity.substr(0, end));

}

// The toolset version a Visual Studio instance selects when none is named:

// `VC/Auxiliary/Build/Microsoft.VCToolsVersion.default.txt`, which the

// Visual Studio installer writes and CMake and vcpkg both read.

inline std::string instance_default_version(const std::filesystem::path& instance) {

std::ifstream in(instance / "VC" / "Auxiliary" / "Build" / "Microsoft.VCToolsVersion.default.txt");

std::string v;

std::getline(in, v);

while (!v.empty() && (v.back() == '\r' || v.back() == ' ' || v.back() == '\n')) v.pop_back();

return v;

}

// tool_env() is one KEY=value per line.

inline std::vector<std::pair<std::string, std::string>> parse_env(std::string_view text) {

std::vector<std::pair<std::string, std::string>> out;

while (!text.empty()) {

const auto nl = text.find('\n');

std::string_view line = text.substr(0, nl);

text = nl == std::string_view::npos ? std::string_view{} : text.substr(nl + 1);

if (!line.empty() && line.back() == '\r') line.remove_suffix(1);

const auto eq = line.find('=');

if (eq == std::string_view::npos || eq == 0) continue;

out.emplace_back(std::string(line.substr(0, eq)), std::string(line.substr(eq + 1)));

}

return out;

}

inline bool same_key(std::string_view a, std::string_view b) {

if (a.size() != b.size()) return false;

for (std::size_t i = 0; i < a.size(); ++i)

if (std::tolower(static_cast<unsigned char>(a[i])) != std::tolower(static_cast<unsigned char>(b[i])))

return false;

return true;

}

// The value of `key` in `env`; Windows environment names compare without case.

inline std::string env_value(const std::vector<std::pair<std::string, std::string>>& env,

std::string_view key) {

for (auto const& [k, v] : env) if (same_key(k, key)) return v;

return {};

}

namespace detail {

inline std::string tool_of(compiler which, const char* role) {

return forward(which == compiler::abi_native ? mcpp::abi_tool(role) : mcpp::tool(role));

}

inline void add_dir(std::vector<std::string>& dirs, const std::string& file) {

if (file.empty()) return;

const std::string dir = std::filesystem::path(file).parent_path().generic_string();

if (dir.empty()) return;

for (auto const& d : dirs) if (same_key(d, dir)) return;

dirs.push_back(dir);

}

inline std::expected<resolved_tools, std::string> chain(const choice& c, resolved_tools r) {

r.how = mechanism::chain;

r.cc = tool_of(c.cc, "cc");

r.cxx = tool_of(c.cc, "cxx");

r.ld = tool_of(c.cc, "ld");

r.ar = tool_of(c.cc, "ar");

r.rc = tool_of(c.cc, "rc");

r.mt = tool_of(c.cc, "mt");

if (r.cxx.empty())

return std::unexpected(std::format(

"the resolved toolchain states no {} C++ compiler for target '{}'; the engine "

"states the tools from mcpp 2026.9.28.3 onward.",

c.cc == compiler::abi_native ? "ABI-native" : "row", std::string(mcpp::target())));

if (r.cc.empty()) r.cc = r.cxx;

if (r.msvc_abi) {

// The environment WITHOUT its PATH. The engine's PATH is the cl.exe

// directory followed by the whole PATH of the process that ran mcpp --

// under Git Bash that holds Git's own msys tools and runtime, and a

// make-based port configured against them failed (`configure: error:

// invalid variable name: '0'`, icu, the plugins' CI). The tools'

// own directories are the PATH a foreign system needs: the toolset's

// bin (cl, link, lib) and the SDK's (rc, mt).

for (auto const& kv : parse_env(mcpp::tool_env()))

if (!same_key(kv.first, "PATH")) r.env.push_back(kv);

for (auto const* t : { &r.cxx, &r.cc, &r.ld, &r.rc, &r.mt }) add_dir(r.path_dirs, *t);

} else {

for (auto const* t : { &r.cxx, &r.cc }) add_dir(r.path_dirs, *t);

}

return r;

}

} // namespace detail

// The tools a foreign build system is handed, and how.

inline std::expected<resolved_tools, std::string> resolve(const choice& c = {}) {

resolved_tools r;

r.identity = mcpp::toolset_identity();

r.crt = mcpp::msvc_crt_linkage();

r.msvc_abi = msvc_abi();

if (r.msvc_abi) r.toolset_version = msvc_version_of(r.identity);

if (c.toolset == source::detected) {

const auto kept = mcpp::plugins::compat::detected_toolset();

// Where detection cannot agree with the program -- the host compiler

// on Linux uses libstdc++ while the program uses libc++ -- 0.16.0

// already named mcpp's clang, and so does this.

if (kept.name_compilers) return detail::chain({source::resolved, compiler::row}, r);

r.how = mechanism::detected;

return r;

}

if (r.identity.empty())

return std::unexpected(std::string(

"the engine states no toolset identity: build information for build programs "

"arrived in mcpp 2026.9.28.3 (protocol 14). Pin \"mcpp\": \"2026.9.28.3\" or newer "

"in .xlings.json, or set the plugin's `toolset` option to `detected`."));

// THE GCC PAYLOAD IS NOT A COMPLETE HANDOVER. mcpp runs it with a sysroot,

// a binutils directory and a link model (`--sysroot`, `-B`, the payload's

// dynamic linker and C library) that its own command lines add and a

// foreign build system does not receive; given the driver alone, vcpkg's

// compiler detection failed on CI while it passed on a machine whose host

// compiler filled the gaps. The clang payloads carry their configuration in

// their own `.cfg` files and are complete. On the GCC row the host

// compiler's libstdc++ is the same C++ library, so the foreign system's

// detection agrees with the program, as it did before 0.17.0.

if (!r.msvc_abi && std::string_view(mcpp::compiler()) == "gcc") {

r.how = mechanism::detected;

r.reason = "the GCC payload runs with a sysroot, binutils and a link model that only mcpp's "

"own command lines carry; the host compiler's libstdc++ is the program's C++ library";

return r;

}

const std::string instance = forward(mcpp::msvc_instance_dir());

if (r.msvc_abi && !instance.empty() && c.cc == compiler::abi_native) {

r.how = mechanism::instance;

r.instance_dir = instance;

r.instance_default = instance_default_version(std::filesystem::path(instance));

r.cc = r.cxx = detail::tool_of(compiler::abi_native, "cxx");

return r;

}

return detail::chain(c, r);

}

// The tools named even where an instance exists: a plugin whose foreign

// system is driven without the instance's own loading (CMake's Ninja

// generator) asks for this. `detected` is answered as by `resolve`.

inline std::expected<resolved_tools, std::string> resolve_named(const choice& c = {}) {

auto r = resolve(c);

if (!r || r->how != mechanism::instance) return r;

resolved_tools base;

base.identity = r->identity;

base.crt = r->crt;

base.msvc_abi = r->msvc_abi;

base.toolset_version = r->toolset_version;

return detail::chain(c, base);

}

// A one-line account of a resolution, for a plugin's own diagnostics and for

// the identity comment of a generated file.

inline std::string describe(const resolved_tools& r) {

std::string s = std::format("{} ({})", r.identity.empty() ? std::string("unknown toolset") : r.identity,

name(r.how));

if (r.how == mechanism::instance) s += std::format(", instance {}", r.instance_dir);

if (!r.crt.empty()) s += std::format(", crt {}", r.crt);

return s;

}

} // namespace mcpp::plugins::toolset