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));

}

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)

{

// A DISTRIBUTION package may carry a leg's link line twice: as `ldflags`

// (GNU spelling, which is all an older mcpp reads) and as the neutral

// `[target.<pred>.runtime]` pair, which mcpp renders per dialect. Applying

// both would put `-L` on a native `cl.exe` command line, which is exactly

// what the neutral form exists to avoid — so where the neutral form is

// present it REPLACES the ldflags rather than adding to them.

//

// Scoped to distribution packages on purpose: a hand-written manifest that

// states both may well mean both (`ldflags` also carries things like

// `-Wl,--as-needed`), and silently dropping half of it would be its own

// silent failure.

const bool generatedPackage = mcpp::pack::is_distribution_package(m);

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

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

const bool neutralWins = generatedPackage

&& (!cc.linkLibraryDirs.empty() || !cc.libraries.empty());

// 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`).

if (neutralWins) {

// ⚠️ Drop the LIBRARY REFERENCES, not the whole ldflags list.

//

// Clearing it outright was a measured regression: a PE/MinGW shared

// leg's ldflags also carry `-Wl,-Bdynamic`, without which `-static`

// leaves ld in static-only mode and it refuses the import library

// with `have you installed the static version of the mathkit

// library?`. e2e 257 caught it.

//

// The neutral form replaces exactly what it can express — a library

// and where to find it. Anything else in that block says something

// it cannot say, and must survive.

auto inputs = cc.inputs;

std::erase_if(inputs.ldflags, [](std::string_view f) {

return f.starts_with("-L") || f.starts_with("-l")

|| f.starts_with("/LIBPATH:");

});

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

} else {

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

}

// The neutral half goes where `render_link_intent_flags` will find it.

for (auto const& d : cc.linkLibraryDirs)

m.runtimeConfig.linkIntent.linkLibraryDirs.push_back(d);

for (auto const& l : cc.libraries)

m.runtimeConfig.linkIntent.libraries.push_back(l);

// `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;

const mcpp::toolchain::Toolchain* tc)

{

e.toolchainDir = (tc && !tc->binaryPath.empty())

? tc->binaryPath.parent_path().parent_path().string() : std::string{};

e.targetSysroot = tc ? tc->targetSysrootRoot.string() : std::string{};

e.targetLibc = tc ? tc->targetSysrootPkg : std::string{};

if (!tc) return;

// The C LIBRARY's sub-directory for this ISA profile, from the freestanding

// table — the same single read point the compile flags use.

//

// ⚠️ Gated on there being a C library at all, and the gate is the point: the

// value is a multilib convention, so on the zero-libc tier there is nothing

// for it to be a convention OF. Emitting `rv64gc/lp64d` there would hand a

// kernel a path into a directory that does not exist, and the name of the

// accessor would be a lie. All three libc-facing answers are empty together.

if (!e.targetSysroot.empty())

if (auto spec = mcpp::freestanding::resolve(tc->targetTriple))

e.targetLibcProfile = std::string(spec->libdir);

// Which builtins library the RESOLVED toolchain ships. Freestanding only:

// on a hosted target the driver links them without being asked, and

// handing a package a name it must not use would invite it to.

if (auto t = mcpp::toolchain::triple::parse(tc->targetTriple);

t && t->is_freestanding()) {

e.targetBuiltinsLib = mcpp::toolchain::is_clang(*tc)

? "clang_rt.builtins-" + t->arch

: std::string("gcc");

}

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

msg += "\n" + hint;

return msg;