251 lines
9.3 KiB
C++
251 lines
9.3 KiB
C++
/*
|
|
Crafter® Build
|
|
Copyright (C) 2026 Catcrafts®
|
|
Catcrafts.net
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License version 3.0 as published by the Free Software Foundation;
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
module Crafter.Build:External_impl;
|
|
import std;
|
|
import :External;
|
|
import :Platform;
|
|
namespace fs = std::filesystem;
|
|
using namespace Crafter;
|
|
|
|
namespace {
|
|
|
|
std::string DeriveName(const GitSource& source) {
|
|
std::string url = source.url;
|
|
while (!url.empty() && (url.back() == '/' || url.back() == '\\')) url.pop_back();
|
|
if (url.ends_with(".git")) url.resize(url.size() - 4);
|
|
auto slash = url.find_last_of("/\\");
|
|
return slash == std::string::npos ? url : url.substr(slash + 1);
|
|
}
|
|
|
|
std::string ShellQuote(std::string_view s) {
|
|
std::string out = "'";
|
|
for (char c : s) {
|
|
if (c == '\'') out += "'\\''";
|
|
else out += c;
|
|
}
|
|
out += "'";
|
|
return out;
|
|
}
|
|
|
|
std::string JoinOptions(std::span<const std::string> options) {
|
|
std::string out;
|
|
for (const std::string& opt : options) {
|
|
if (!out.empty()) out += ' ';
|
|
out += ShellQuote(opt);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
|
|
auto runGit = [](std::string_view cmd) -> std::optional<std::string> {
|
|
CommandResult r = RunCommandChecked(cmd);
|
|
if (r.exitCode != 0) return std::format("`{}` failed (exit {}): {}", cmd, r.exitCode, r.output);
|
|
return std::nullopt;
|
|
};
|
|
|
|
if (fs::exists(cloneDir)) {
|
|
CommandResult remote = RunCommandChecked(std::format("git -C {} remote get-url origin", ShellQuote(cloneDir.string())));
|
|
std::string currentUrl = remote.output;
|
|
while (!currentUrl.empty() && (currentUrl.back() == '\n' || currentUrl.back() == '\r')) currentUrl.pop_back();
|
|
if (remote.exitCode != 0 || currentUrl != source.url) {
|
|
fs::remove_all(cloneDir);
|
|
} else if (!source.commit.empty()) {
|
|
CommandResult head = RunCommandChecked(std::format("git -C {} rev-parse HEAD", ShellQuote(cloneDir.string())));
|
|
std::string currentHead = head.output;
|
|
while (!currentHead.empty() && (currentHead.back() == '\n' || currentHead.back() == '\r')) currentHead.pop_back();
|
|
if (head.exitCode == 0 && currentHead != source.commit) {
|
|
if (auto err = runGit(std::format("git -C {} fetch origin", ShellQuote(cloneDir.string())))) return *err;
|
|
if (auto err = runGit(std::format("git -C {} checkout {}", ShellQuote(cloneDir.string()), ShellQuote(source.commit)))) return *err;
|
|
}
|
|
return "";
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
fs::path tmpDir = cloneDir;
|
|
tmpDir += ".tmp";
|
|
if (fs::exists(tmpDir)) fs::remove_all(tmpDir);
|
|
|
|
if (auto err = runGit(std::format("git clone --recursive {} {}", ShellQuote(source.url), ShellQuote(tmpDir.string())))) {
|
|
if (fs::exists(tmpDir)) fs::remove_all(tmpDir);
|
|
return *err;
|
|
}
|
|
if (!source.branch.empty()) {
|
|
if (auto err = runGit(std::format("git -C {} switch {}", ShellQuote(tmpDir.string()), ShellQuote(source.branch)))) {
|
|
fs::remove_all(tmpDir);
|
|
return *err;
|
|
}
|
|
}
|
|
if (!source.commit.empty()) {
|
|
if (auto err = runGit(std::format("git -C {} checkout {}", ShellQuote(tmpDir.string()), ShellQuote(source.commit)))) {
|
|
fs::remove_all(tmpDir);
|
|
return *err;
|
|
}
|
|
}
|
|
|
|
std::error_code ec;
|
|
fs::rename(tmpDir, cloneDir, ec);
|
|
if (ec) {
|
|
fs::remove_all(tmpDir);
|
|
return std::format("rename {} -> {} failed: {}", tmpDir.string(), cloneDir.string(), ec.message());
|
|
}
|
|
return "";
|
|
}
|
|
|
|
std::string BuildInjectedCMakeFlags(const fs::path& cmakeBuildDir) {
|
|
std::string out;
|
|
out += " -DCMAKE_C_COMPILER=clang";
|
|
out += " -DCMAKE_CXX_COMPILER=clang++";
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
|
out += " -DCMAKE_CXX_FLAGS=-stdlib=libc++";
|
|
out += " -DCMAKE_EXE_LINKER_FLAGS=-stdlib=libc++";
|
|
out += " -DCMAKE_SHARED_LINKER_FLAGS=-stdlib=libc++";
|
|
#endif
|
|
fs::path absBuildDir = fs::absolute(cmakeBuildDir);
|
|
out += std::format(" -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY={}", ShellQuote(absBuildDir.string()));
|
|
out += std::format(" -DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}", ShellQuote(absBuildDir.string()));
|
|
return out;
|
|
}
|
|
|
|
std::string ConfigureCMake(const fs::path& cloneDir, const fs::path& cmakeBuildDir, std::span<const std::string> options) {
|
|
fs::path optionsFile = cmakeBuildDir / ".crafter-options";
|
|
std::string optionsKey = JoinOptions(options);
|
|
|
|
bool needsConfigure = !fs::exists(cmakeBuildDir / "CMakeCache.txt");
|
|
if (!needsConfigure) {
|
|
std::ifstream existing(optionsFile);
|
|
if (!existing) {
|
|
needsConfigure = true;
|
|
} else {
|
|
std::stringstream buf;
|
|
buf << existing.rdbuf();
|
|
if (buf.str() != optionsKey) needsConfigure = true;
|
|
}
|
|
}
|
|
|
|
if (!needsConfigure) return "";
|
|
|
|
if (!fs::exists(cmakeBuildDir)) fs::create_directories(cmakeBuildDir);
|
|
|
|
std::string cmd = std::format("cmake -S {} -B {}{}",
|
|
ShellQuote(fs::absolute(cloneDir).string()),
|
|
ShellQuote(fs::absolute(cmakeBuildDir).string()),
|
|
BuildInjectedCMakeFlags(cmakeBuildDir));
|
|
if (!options.empty()) {
|
|
cmd += " ";
|
|
cmd += optionsKey;
|
|
}
|
|
|
|
CommandResult r = RunCommandChecked(cmd);
|
|
if (r.exitCode != 0) {
|
|
return std::format("cmake configure failed (exit {}): {}", r.exitCode, r.output);
|
|
}
|
|
|
|
std::ofstream(optionsFile) << optionsKey;
|
|
return "";
|
|
}
|
|
|
|
std::string BuildCMake(const fs::path& cmakeBuildDir) {
|
|
std::string cmd = std::format("cmake --build {}", ShellQuote(fs::absolute(cmakeBuildDir).string()));
|
|
CommandResult r = RunCommandChecked(cmd);
|
|
if (r.exitCode != 0) {
|
|
return std::format("cmake --build failed (exit {}): {}", r.exitCode, r.output);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
} // namespace
|
|
|
|
ExternalBuildResult Crafter::BuildExternal(
|
|
const ExternalDependency& dep,
|
|
std::atomic<bool>& cancelled) {
|
|
ExternalBuildResult result;
|
|
|
|
if (cancelled.load(std::memory_order_relaxed)) return result;
|
|
|
|
std::string name = dep.name.empty() ? DeriveName(dep.source) : dep.name;
|
|
if (name.empty()) {
|
|
result.error = std::format("Could not derive name for external dependency from URL '{}'", dep.source.url);
|
|
return result;
|
|
}
|
|
|
|
fs::path externalRoot = GetCacheDir() / "external";
|
|
if (!fs::exists(externalRoot)) {
|
|
std::error_code ec;
|
|
fs::create_directories(externalRoot, ec);
|
|
if (ec) {
|
|
result.error = std::format("Failed to create {}: {}", externalRoot.string(), ec.message());
|
|
return result;
|
|
}
|
|
}
|
|
|
|
std::string keyMaterial = std::format("{}|{}|{}|{}",
|
|
dep.source.url, dep.source.branch, dep.source.commit, JoinOptions(dep.options));
|
|
std::size_t key = std::hash<std::string>{}(keyMaterial);
|
|
fs::path cloneDir = externalRoot / std::format("{}-{:016x}", name, key);
|
|
|
|
std::string fetchErr = FetchGit(dep.source, cloneDir);
|
|
if (!fetchErr.empty()) {
|
|
result.error = std::format("git fetch for '{}': {}", name, fetchErr);
|
|
return result;
|
|
}
|
|
|
|
if (cancelled.load(std::memory_order_relaxed)) return result;
|
|
|
|
fs::path cmakeBuildDir;
|
|
if (dep.builder == ExternalBuilder::CMake) {
|
|
cmakeBuildDir = cloneDir / "build";
|
|
if (std::string err = ConfigureCMake(cloneDir, cmakeBuildDir, dep.options); !err.empty()) {
|
|
result.error = std::format("cmake configure for '{}': {}", name, err);
|
|
return result;
|
|
}
|
|
if (cancelled.load(std::memory_order_relaxed)) return result;
|
|
if (std::string err = BuildCMake(cmakeBuildDir); !err.empty()) {
|
|
result.error = std::format("cmake build for '{}': {}", name, err);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
for (const fs::path& include : dep.includeDirs) {
|
|
fs::path full = include.empty() ? cloneDir : cloneDir / include;
|
|
result.compileFlags.push_back(std::format("-I{}", fs::absolute(full).string()));
|
|
}
|
|
|
|
if (dep.builder == ExternalBuilder::CMake) {
|
|
result.linkFlags.push_back(std::format("-L{}", fs::absolute(cmakeBuildDir).string()));
|
|
for (const std::string& lib : dep.libs) {
|
|
result.linkFlags.push_back(std::format("-l{}", lib));
|
|
}
|
|
|
|
if (fs::exists(cmakeBuildDir)) {
|
|
for (const auto& entry : fs::directory_iterator(cmakeBuildDir)) {
|
|
if (!entry.is_regular_file()) continue;
|
|
const fs::path& p = entry.path();
|
|
if (p.extension() != ".a" && p.extension() != ".so") continue;
|
|
std::error_code ec;
|
|
fs::file_time_type t = entry.last_write_time(ec);
|
|
if (!ec && t > result.latestArtifact) result.latestArtifact = t;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|