std::string_view depLabel) {

for (auto const& key : dm.xpkgUnknownKeys) {

auto suggestion = mcpp::manifest::closest_known_xpkg_key(key);

if (suggestion.empty())

mcpp::ui::warning(std::format(

"dependency '{}': unknown mcpp-segment key '{}' in its xpkg "

"descriptor — ignored (schema mismatch or typo)", depLabel, key));

else

mcpp::ui::warning(std::format(

"dependency '{}': unknown mcpp-segment key '{}' in its xpkg "

"descriptor — ignored; did you mean '{}'?", depLabel, key, suggestion));

}

namespace triple = mcpp::toolchain::triple;

Ctx c;

auto t = targetTriple.empty()

? std::optional<triple::Triple>(triple::host_triple())

: triple::parse(targetTriple);

if (t) {

c.os = t->os;

c.arch = t->arch;

c.env = t->env;

c.family = t->family();

} else {

// Escape-hatch triple outside the language: only the leading arch

// segment is derivable; other dimensions stay empty (never match).

auto dash = targetTriple.find('-');

c.arch = std::string(dash == std::string_view::npos ? targetTriple

: targetTriple.substr(0, dash));

}

return c;

std::string_view s; std::size_t i = 0; const Ctx& c;

void ws() { while (i < s.size() && std::isspace((unsigned char)s[i])) ++i; }

bool eat(char ch) { ws(); if (i < s.size() && s[i] == ch) { ++i; return true; } return false; }

std::string ident() {

ws(); std::size_t b = i;

while (i < s.size() && (std::isalnum((unsigned char)s[i]) || s[i] == '_')) ++i;

return std::string(s.substr(b, i - b));

}

std::string str() {

ws(); if (i >= s.size() || s[i] != '"') return {};

++i; std::size_t b = i; while (i < s.size() && s[i] != '"') ++i;

auto v = std::string(s.substr(b, i - b)); if (i < s.size()) ++i; return v;

}

bool match_alias(const std::string& a) {

if (a == "windows") return c.os == "windows";

if (a == "linux") return c.os == "linux";

if (a == "macos") return c.os == "macos";

if (a == "unix") return c.family == "unix";

return false; // unknown bareword → no match

}

bool match_kv(const std::string& k, const std::string& v) {

if (k == "os") return c.os == v;

if (k == "arch") return c.arch == v;

if (k == "family") return c.family == v;

if (k == "env") return c.env == v;

return false;

}

bool expr() {

std::string id = ident();

if (id == "all" || id == "any") {

eat('(');

bool acc = (id == "all");

ws();

if (!(i < s.size() && s[i] == ')')) {

do { bool r = expr(); acc = (id == "all") ? (acc && r) : (acc || r); }

while (eat(','));

}

eat(')');

return acc;

}

if (id == "not") { eat('('); bool r = expr(); eat(')'); return !r; }

ws();

if (i < s.size() && s[i] == '=') { ++i; return match_kv(id, str()); }

return match_alias(id);

}

std::string_view k = predicate;

if (k.starts_with("cfg(") && k.ends_with(")")) {

Parser p{ k.substr(4, k.size() - 5), 0, c };

return p.expr();

}

// Bare OS/family alias sugar: `[target.linux]` ≡ `[target.'cfg(linux)']`.

// These aliases are never valid triples (no dash), so there is no ambiguity

// with the exact-triple namespace. Evaluated as the cfg bareword.

if (predicate == "windows" || predicate == "linux" ||

predicate == "macos" || predicate == "unix") {

Parser p{ predicate, 0, c };

return p.expr();

}

// Bare-triple match, spelling-independent: a `[target.x86_64-w64-mingw32]`

// key matches a resolved `x86_64-windows-gnu` build (and vice versa) —

// both normalize through triple::parse. Unparseable keys (the explicit-

// section escape hatch) fall back to exact string comparison.

if (triple.empty()) return false;

if (auto p = mcpp::toolchain::triple::parse(predicate)) {

if (auto rt = mcpp::toolchain::triple::parse(triple))

return p->str() == rt->str();

}

return predicate == triple;

const std::vector<mcpp::modgraph::PackageRoot>& packages)

{

std::string s;

for (auto const& pkg : packages) {

s += "\npackage:";

s += pkg.manifest.package.namespace_;

s += "/";

s += pkg.manifest.package.name;

s += "@";

s += pkg.manifest.package.version;

if (!pkg.manifest.buildConfig.cStandard.empty()) {

s += " c_standard=";

s += pkg.manifest.buildConfig.cStandard;

}

for (auto const& flag : pkg.manifest.buildConfig.cflags) {

s += " cflag:";

s += flag;

}

for (auto const& flag : pkg.manifest.buildConfig.cxxflags) {

s += " cxxflag:";

s += flag;

}

for (auto const& flag : pkg.manifest.buildConfig.ldflags) {

s += " ldflag:";

s += flag;

}

// Per-glob flags — same full ordered serialization as the root-side

// block above. Until #253 dependency globFlags were unfingerprinted

// (held only by "descriptor frozen per version" + "feature toggles

// always change cflags via -DMCPP_FEATURE_*"); feature-folded entries

// make the vector build-variant, so fingerprint it directly.

// featureOrigin is diagnostic-only and deliberately NOT serialized

// (the active feature set is already in cflags above).

for (auto const& gf : pkg.manifest.buildConfig.globFlags) {

s += " globflags:"; s += gf.glob;

for (auto const& f : gf.cflags) { s += " gc:"; s += f; }

for (auto const& f : gf.cxxflags) { s += " gxx:"; s += f; }

for (auto const& f : gf.asmflags) { s += " gas:"; s += f; }

for (auto const& f : gf.defines) { s += " gd:"; s += f; }

}

if (pkg.usageResolved) {

for (auto const& dir : pkg.privateBuild.includeDirs) {

s += " private_include:";

s += dir.generic_string();

}

for (auto const& dir : pkg.publicUsage.includeDirs) {

s += " public_include:";

s += dir.generic_string();

}

for (auto const& dir : pkg.privateBuild.includeDirsAfter) {

s += " private_include_after:";

s += dir.generic_string();

}

for (auto const& dir : pkg.publicUsage.includeDirsAfter) {

s += " public_include_after:";

s += dir.generic_string();

}

}

for (auto const& [path, content] : pkg.manifest.buildConfig.generatedFiles) {

s += " genfile:";

s += path.generic_string();

s += "=";

s += content;

}

}

return s;

const mcpp::manifest::Manifest& manifest)

{

for (auto const& [relPath, content] : manifest.buildConfig.generatedFiles) {

if (relPath.empty()) {

return std::unexpected("generated_files contains an empty path");

}

if (relPath.is_absolute()) {

return std::unexpected(std::format(

"generated_files path '{}' must be relative", relPath.generic_string()));

}

auto const genericPath = relPath.generic_string();

for (std::size_t begin = 0; begin <= genericPath.size();) {

auto const end = genericPath.find('/', begin);

auto const part = genericPath.substr(begin, end == std::string::npos

? std::string::npos

: end - begin);

if (part == "..") {

return std::unexpected(std::format(

"generated_files path '{}' must not escape the package root",

relPath.generic_string()));

}

if (end == std::string::npos) {

break;

}

begin = end + 1;

}

auto out = root / relPath.lexically_normal();

std::error_code ec;

std::filesystem::create_directories(out.parent_path(), ec);

if (ec) {

return std::unexpected(std::format(

"cannot create directory for generated file '{}': {}",

out.string(), ec.message()));

}

// Skip the write when the on-disk content is already identical: ninja

// is mtime-driven, and an unconditional rewrite bumps the mtime every

// build, recompiling every TU that #includes the materialized file

// (via depfiles) — e.g. a frozen-snapshot config.h included by

// thousands of TUs. Change detection is already owned by the

// fingerprint (content is folded in above), so skipping only

// preserves the mtime — mirroring the build.mcpp cache design,

// which likewise avoids mtime churn on unchanged outputs.

{

std::ifstream is(out, std::ios::binary);

if (is) {

std::string existing((std::istreambuf_iterator<char>(is)),

std::istreambuf_iterator<char>());

if (is && existing == content) {

continue;

}

}

}

std::ofstream os(out, std::ios::binary);

if (!os) {

return std::unexpected(std::format(

"cannot write generated file '{}'", out.string()));

}

os << content;

if (!os) {

return std::unexpected(std::format(

"failed while writing generated file '{}'", out.string()));

}

}

return {};

const cfgpred::Ctx& ctx,

std::string_view targetTriple)

{

for (auto const& cc : m.conditionalConfigs) {

if (!cfgpred::matches(cc.predicate, ctx, targetTriple)) continue;

// One append() for every field the axis may carry (#258). Matching

// sections land AFTER the base entries, so a conditional rule beats

// a broader unconditional one under GNU last-wins — which is what

// makes an off-OS REMOVAL expressible (`-U` after the base `-D`).

mcpp::manifest::append(m.buildConfig, cc.inputs);

// `modules.sources` is the scanner's own view and is not part of

// BuildInputs, so conditional sources are mirrored into it here.

for (auto const& s : cc.inputs.sources)

m.modules.sources.push_back(s);

// insert() keeps an existing unconditional entry: a conditional

// section adds a dependency, it never silently overrides one.

m.dependencies.insert(cc.dependencies.begin(), cc.dependencies.end());

m.devDependencies.insert(cc.devDependencies.begin(), cc.devDependencies.end());

m.buildDependencies.insert(cc.buildDependencies.begin(),

cc.buildDependencies.end());

// #359: `[target.<sel>.feature-deps.<feature>]`. The feature is

// registered by the parser regardless of the predicate; only what it

// pulls in is conditional.

for (auto const& [fname, deps] : cc.featureDeps) {

auto& dst = m.featureDeps[fname];

dst.insert(deps.begin(), deps.end());

}

}

for (auto const& d : bc.defines) {

bc.cflags.push_back("-D" + d);

bc.cxxflags.push_back("-D" + d);

}

bc.defines.clear();

const std::vector<std::string>& requested,

bool seedDefault = true)

{

std::vector<std::string> act, q;

if (seedDefault)

if (auto it = pm.featuresMap.find("default"); it != pm.featuresMap.end())

q.insert(q.end(), it->second.begin(), it->second.end());

q.insert(q.end(), requested.begin(), requested.end());

std::set<std::string> seen;

while (!q.empty()) {

auto f = q.back(); q.pop_back();

if (f == "default" || !seen.insert(f).second) continue;

act.push_back(f);

if (auto it = pm.featuresMap.find(f); it != pm.featuresMap.end())

q.insert(q.end(), it->second.begin(), it->second.end());

}

return act;

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

for (std::size_t p = 0; p < s.size();) {

auto c = s.find_first_of(", ", p);

auto tok = s.substr(p, c == std::string_view::npos ? std::string_view::npos : c - p);

if (!tok.empty()) out.emplace_back(tok);

if (c == std::string_view::npos) break;

p = c + 1;

}

return out;

while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front())))

s.erase(0, 1);

while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back())))

s.pop_back();

return s;

std::ifstream is(path);

if (!is) return false;

std::string line;

while (std::getline(is, line)) {

line = trim_copy(std::move(line));

std::size_t i = std::string::npos;

if (line.starts_with("import ")) {

i = 7;

} else if (line.starts_with("export import ")) {

i = 14;

}

if (i == std::string::npos) continue;

while (i < line.size() && std::isspace(static_cast<unsigned char>(line[i])))

++i;

std::string name;

while (i < line.size()

&& (std::isalnum(static_cast<unsigned char>(line[i]))

|| line[i] == '_' || line[i] == '.' || line[i] == ':')) {

name.push_back(line[i]);

++i;

}

if (is_std_module(name)) return true;

}

return false;

const mcpp::manifest::Manifest& manifest,

const std::filesystem::path& projectRoot) {

for (auto& u : graph.units) {

for (auto& req : u.requires_) {

if (is_std_module(req.logicalName))

return true;

}

}

// Some target entry files can be added to the plan after the package scan.

// Check them here so std BMI setup matches what make_plan will compile.

for (auto& t : manifest.targets) {

if (!t.main.empty() && source_file_imports_std(projectRoot / t.main))

return true;

}

return false;

std::string name;

std::string version;

std::size_t units = 0;

std::string_view override_mode) {

if (auto v = parse_cache_mode(override_mode)) return *v;

if (const char* e = std::getenv("MCPP_BUILD_CACHE"); e && *e)

if (auto v = parse_cache_mode(e)) return *v;

if (auto v = parse_cache_mode(m.buildConfig.cacheMode)) return *v;

return CacheMode::Global;

if (url.starts_with("file://")) return true;

if (url.contains("://")) return false;

if (url.contains('@') && url.contains(':')) return false;

std::error_code ec;

return std::filesystem::exists(std::filesystem::path(url), ec);

auto r = mcpp::platform::process::capture(std::format(

"git -C {} rev-parse HEAD 2>&1",

mcpp::platform::shell::quote(gitRoot.string())));

if (r.exit_code != 0) return {};

std::string out = r.output;

while (!out.empty() && (out.back() == '\n' || out.back() == '\r'

|| out.back() == ' ' || out.back() == '\t'))

out.pop_back();

if (auto nl = out.find_last_of("\r\n"); nl != std::string::npos)

out.erase(0, nl + 1);

return out;

if (auto hint = mcpp::pm::unusable_index_hint(); !hint.empty())

msg += "\n" + hint;

return msg;

const std::filesystem::path& compilerBin) {

auto runtime_of = [](const std::filesystem::path& dir) -> std::string {

return mcpp::xlings::subos::read(dir).runtime;

};

// A declaration can only be honoured while the payload it names is still

// installed. Subos descriptions are written once and the payloads beneath

// them are replaced independently -- upgraded, garbage-collected -- so a

// subos can go on saying `glibc@2.39` on a machine that now has only 2.44.

//

// Taking that at face value is not conservative, it is worse than any

// substitution: the exact-match probe finds nothing, no loader reaches the

// link line, and the artifact ends up on the HOST loader -- outside the

// sandbox entirely. Measured on CI, three rounds running.

//

// So a declaration naming an absent payload is passed over rather than

// returned, and resolution carries on to something that can be honoured.

auto usable = [&](const std::string& binding) {

if (binding.empty()) return false;

if (compilerBin.empty()) return true; // cannot check yet; caller re-asks

if (mcpp::toolchain::probe_payload_paths(compilerBin, binding))

return true;

mcpp::log::verbose("probe", std::format(

"subos declares runtime {}, but that payload is not installed here "

"— looking for one that is", binding));

return false;

};

if (auto active = mcpp::xlings::paths::subos_dir_of(compilerBin)) {

// 1 — the project names a subos; it is a sibling of the active one.

if (!m.xlings.subos.empty()) {

auto named = active->parent_path() / m.xlings.subos;

if (auto r = runtime_of(named); usable(r)) return r;

}

// 2 — whatever is active.

if (auto r = runtime_of(*active); usable(r)) return r;

}

// 3 — COMPATIBILITY: the value this toolchain already has baked in.

//

// A subos created before xlings grew `subos_info` cannot answer, and that

// is the state of every machine installed before 2026.8.5.1 -- including

// mcpp's own sandbox, whose vendored xlings is never upgraded. Refusing

// there would break every existing user, so the toolchain's own baked

// value stands in.

//

// This is NOT the guess this design removed. The guess picked a version by

// directory order, unrelated to what the artifact would load. This reads

// the value the artifact WILL use -- gcc's specs, clang's cfg -- so the

// invariant that matters, compile side == run side, still holds. It is a

// migration path, and it goes away on its own: once the subos describes

// itself, step 1 or 2 answers first.

if (!compilerBin.empty()) {

if (auto r = mcpp::toolchain::baked_runtime_binding(compilerBin);

!r.empty()) {

mcpp::log::verbose("probe", std::format(

"subos does not describe itself; using the runtime this "

"toolchain was installed against ({}). `xlings self update` "

"and a fresh subos make this authoritative", r));

return r;

}

}

return {};