Jorijn van der Graaf
bc9ceb8f24
All checks were successful
CI / build-test-release (push) Successful in 9m2s
1039 lines
49 KiB
C++
1039 lines
49 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
|
|
*/
|
|
|
|
export module Crafter.Build:Clang_impl;
|
|
import std;
|
|
import :Clang;
|
|
import :Platform;
|
|
import :Test;
|
|
import :Progress;
|
|
namespace fs = std::filesystem;
|
|
using namespace Crafter;
|
|
|
|
|
|
void Configuration::GetInterfacesAndImplementations(std::span<fs::path> interfaces, std::span<fs::path> implementations) {
|
|
auto resolveImport = [this](const std::string& importName,
|
|
std::vector<Module*>& localDeps,
|
|
std::vector<std::pair<Module*, fs::path>>& externalDeps) -> bool {
|
|
for(const std::unique_ptr<Module>& interface : this->interfaces) {
|
|
if(interface->name == importName) {
|
|
localDeps.push_back(interface.get());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
std::unordered_set<Configuration*> seen;
|
|
std::function<bool(Configuration*)> walk = [&](Configuration* depCfg) -> bool {
|
|
if (!seen.insert(depCfg).second) return false;
|
|
for(const std::unique_ptr<Module>& depInterface : depCfg->interfaces) {
|
|
if(depInterface->name == importName) {
|
|
fs::path depPcmPath = (depCfg->PcmDir() / depInterface->path.filename()).string() + ".pcm";
|
|
externalDeps.emplace_back(depInterface.get(), std::move(depPcmPath));
|
|
return true;
|
|
}
|
|
}
|
|
for(Configuration* sub : depCfg->dependencies) {
|
|
if (walk(sub)) return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
for(Configuration* depCfg : this->dependencies) {
|
|
if (walk(depCfg)) return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
std::vector<std::tuple<fs::path, std::string, ModulePartition*, Module*>> tempModulePaths = std::vector<std::tuple<fs::path, std::string, ModulePartition*, Module*>>(interfaces.size());
|
|
for(std::uint16_t i = 0; i < interfaces.size(); i++){
|
|
fs::path file = path / interfaces[i];
|
|
file += ".cppm";
|
|
std::ifstream t(file);
|
|
std::stringstream buffer;
|
|
buffer << t.rdbuf();
|
|
std::string fileContent = buffer.str();
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(//[^\n]*)"), "");
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(/\*.*?\*/)"), "");
|
|
tempModulePaths[i] = {file, fileContent, nullptr, nullptr};
|
|
}
|
|
|
|
std::erase_if(tempModulePaths, [this](std::tuple<fs::path, std::string, ModulePartition*, Module*>& file) {
|
|
std::smatch match;
|
|
if (std::regex_search(std::get<1>(file), match, std::regex(R"(export module ([a-zA-Z0-9_\.\-]+);)"))) {
|
|
std::get<0>(file).replace_extension("");
|
|
this->interfaces.push_back(std::make_unique<Module>(std::move(match[1].str()), std::move(std::get<0>(file))));
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
|
|
for(std::uint16_t i = 0; i < tempModulePaths.size(); i++) {
|
|
std::smatch match;
|
|
if (std::regex_search(std::get<1>(tempModulePaths[i]), match, std::regex(R"(export module ([a-zA-Z_0-9\.\-]+):([a-zA-Z_0-9\.\-]+);)"))) {
|
|
for(const std::unique_ptr<Module>& modulee : this->interfaces) {
|
|
if(modulee->name == match[1]) {
|
|
std::string name = match[2].str();
|
|
fs::path pthCpy = std::get<0>(tempModulePaths[i]);
|
|
pthCpy.replace_extension("");
|
|
std::unique_ptr<ModulePartition> partition = std::make_unique<ModulePartition>(std::move(name), std::move(pthCpy));
|
|
std::get<2>(tempModulePaths[i]) = partition.get();
|
|
modulee->partitions.push_back(std::move(partition));
|
|
std::get<3>(tempModulePaths[i]) = modulee.get();
|
|
goto next;
|
|
}
|
|
}
|
|
throw std::runtime_error(std::format("Module {} not found, referenced in {}", match[1].str(), std::get<0>(tempModulePaths[i]).string()));
|
|
} else {
|
|
throw std::runtime_error(std::format("No module declaration found in {}", std::get<0>(tempModulePaths[i]).string()));
|
|
}
|
|
next:;
|
|
}
|
|
|
|
for(std::tuple<fs::path, std::string, ModulePartition*, Module*>& file : tempModulePaths) {
|
|
ModulePartition* partition = std::get<2>(file);
|
|
Module* parentModule = std::get<3>(file);
|
|
const std::string& fileContent = std::get<1>(file);
|
|
|
|
std::regex partitionPattern(R"(import :([a-zA-Z_\-0-9\.]+);)");
|
|
std::sregex_iterator currentMatch(fileContent.begin(), fileContent.end(), partitionPattern);
|
|
std::sregex_iterator lastMatch;
|
|
while (currentMatch != lastMatch) {
|
|
std::smatch match = *currentMatch;
|
|
for(std::unique_ptr<ModulePartition>& sibling : parentModule->partitions) {
|
|
if(sibling->name == match[1]) {
|
|
partition->partitionDependencies.push_back(sibling.get());
|
|
goto next2;
|
|
}
|
|
}
|
|
throw std::runtime_error(std::format("imported partition {}:{} not found, referenced in {}", parentModule->name, match[1].str(), std::get<0>(file).string()));
|
|
next2: ++currentMatch;
|
|
}
|
|
|
|
std::regex modulePattern(R"(import ([a-zA-Z_0-9\.\-]+);)");
|
|
std::sregex_iterator modCurrent(fileContent.begin(), fileContent.end(), modulePattern);
|
|
while (modCurrent != lastMatch) {
|
|
std::smatch match = *modCurrent;
|
|
resolveImport(match[1].str(), partition->moduleDependencies, partition->externalModuleDependencies);
|
|
++modCurrent;
|
|
}
|
|
}
|
|
|
|
for(const fs::path& tempFile : implementations) {
|
|
fs::path file = path / tempFile;
|
|
file += ".cpp";
|
|
std::ifstream t(file);
|
|
std::stringstream buffer;
|
|
buffer << t.rdbuf();
|
|
std::string fileContent = buffer.str();
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(//[^\n]*)"), "");
|
|
fileContent = std::regex_replace(fileContent, std::regex(R"(/\*.*?\*/)"), "");
|
|
std::smatch match;
|
|
fs::path fileCopy = file;
|
|
fileCopy.replace_extension("");
|
|
Implementation& implementation = this->implementations.emplace_back(std::move(fileCopy));
|
|
if (std::regex_search(fileContent, match, std::regex(R"(module ([a-zA-Z0-9_\.\-]+)(:[a-zA-Z0-9_\.\-]+)?\s*;)"))) {
|
|
bool isPartitionImpl = match[2].length() > 0;
|
|
for(const std::unique_ptr<Module>& interface : this->interfaces) {
|
|
if(interface->name == match[1]) {
|
|
if (!isPartitionImpl) {
|
|
implementation.moduleDependencies.push_back(interface.get());
|
|
}
|
|
std::regex partitionPattern(R"(import :([a-zA-Z_\-0-9\.]+);)");
|
|
std::sregex_iterator currentMatch(fileContent.begin(), fileContent.end(), partitionPattern);
|
|
std::sregex_iterator lastMatch;
|
|
while (currentMatch != lastMatch) {
|
|
std::smatch match2 = *currentMatch;
|
|
for(const std::unique_ptr<ModulePartition>& partition : interface->partitions) {
|
|
if(partition->name == match2[1]) {
|
|
implementation.partitionDependencies.push_back(partition.get());
|
|
goto next3;
|
|
}
|
|
}
|
|
throw std::runtime_error(std::format("imported partition {}:{} not found, referenced in {}", match[1].str(), match2[1].str(), file.string()));
|
|
next3: ++currentMatch;
|
|
}
|
|
|
|
std::regex modulePattern(R"(import ([a-zA-Z_0-9\.\-]+);)");
|
|
std::sregex_iterator modCurrent(fileContent.begin(), fileContent.end(), modulePattern);
|
|
while (modCurrent != lastMatch) {
|
|
std::smatch match2 = *modCurrent;
|
|
if (match2[1] != match[1]) {
|
|
resolveImport(match2[1].str(), implementation.moduleDependencies, implementation.externalModuleDependencies);
|
|
}
|
|
++modCurrent;
|
|
}
|
|
goto next4;
|
|
}
|
|
}
|
|
throw std::runtime_error(std::format("Module {} not found not found, referenced in {}", match[1].str(), file.string()));
|
|
next4:;
|
|
} else {
|
|
std::regex pattern(R"(import ([a-zA-Z_\-0-9\.]+);)");
|
|
std::sregex_iterator currentMatch(fileContent.begin(), fileContent.end(), pattern);
|
|
std::sregex_iterator lastMatch;
|
|
while (currentMatch != lastMatch) {
|
|
std::smatch match2 = *currentMatch;
|
|
resolveImport(match2[1].str(), implementation.moduleDependencies, implementation.externalModuleDependencies);
|
|
++currentMatch;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BuildResult Crafter::Build(Configuration& config, std::unordered_map<fs::path, std::shared_future<BuildResult>>& depResults, std::mutex& depMutex) {
|
|
// Reset per-build cached state on every Module/ModulePartition so that
|
|
// successive Build() calls on the same Configuration re-evaluate mtimes
|
|
// (incremental-rebuild test scenarios). Walks cfg.dependencies recursively
|
|
// with a seen-set so diamond deps don't loop.
|
|
{
|
|
std::unordered_set<Configuration*> resetSeen;
|
|
std::function<void(Configuration*)> reset = [&](Configuration* c) {
|
|
if (!resetSeen.insert(c).second) return;
|
|
for (auto& iface : c->interfaces) {
|
|
iface->checked = false;
|
|
iface->compiled.store(false);
|
|
for (auto& part : iface->partitions) {
|
|
part->checked = false;
|
|
part->compiled.store(false);
|
|
}
|
|
}
|
|
for (Configuration* dep : c->dependencies) {
|
|
reset(dep);
|
|
}
|
|
};
|
|
reset(&config);
|
|
}
|
|
|
|
// Auto-detect the WASI sysroot before any compile step runs so BuildStdPcm
|
|
// and the main compile command see the same value. Linux-only — Windows
|
|
// users supply cfg.sysroot pointing at their wasi-sdk install. Covers all
|
|
// wasm32-* triples (wasi, wasip1, wasip2, ...); the sysroot's per-triple
|
|
// subdirs handle the differences.
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
|
if (config.sysroot.empty() && config.target.starts_with("wasm32")) {
|
|
config.sysroot = "/usr/share/wasi-sysroot";
|
|
}
|
|
#endif
|
|
|
|
fs::path buildDir = config.path/"build"/std::format("{}-{}-{}", config.name, config.target, config.march);
|
|
fs::path outputDir = config.path/"bin"/std::format("{}-{}-{}", config.name, config.target, config.march);
|
|
|
|
if (!fs::exists(buildDir)) {
|
|
fs::create_directories(buildDir);
|
|
}
|
|
|
|
if (!fs::exists(outputDir)) {
|
|
fs::create_directories(outputDir);
|
|
}
|
|
|
|
BuildResult buildResult;
|
|
|
|
std::vector<std::thread> threads;
|
|
threads.reserve(config.shaders.size() + 1 + config.interfaces.size() + config.implementations.size());
|
|
|
|
std::string buildError;
|
|
std::atomic<bool> buildCancelled{false};
|
|
for (const Shader& shader : config.shaders) {
|
|
if (shader.Check(outputDir)) continue;
|
|
threads.emplace_back([&shader, &outputDir, &buildError, &buildCancelled]() {
|
|
Progress::Task task(std::format("Compiling shader {}", shader.path.filename().string()));
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
|
|
std::string result = shader.Compile(outputDir);
|
|
if (result.empty()) return;
|
|
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::move(result);
|
|
}
|
|
});
|
|
}
|
|
|
|
threads.emplace_back([&config, &outputDir, &buildCancelled, &buildError]() {
|
|
Progress::Task task(std::format("Copying files for {}", config.name));
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
try {
|
|
for (const fs::path& additionalFile : config.files) {
|
|
fs::path destination = outputDir / additionalFile.filename();
|
|
|
|
if (fs::is_directory(additionalFile)) {
|
|
for (const auto& entry : fs::recursive_directory_iterator(additionalFile)) {
|
|
|
|
const fs::path& sourcePath = entry.path();
|
|
|
|
// Compute relative path inside the directory
|
|
fs::path relativePath = fs::relative(sourcePath, additionalFile);
|
|
fs::path destPath = destination / relativePath;
|
|
|
|
if (entry.is_directory()) {
|
|
// Ensure directory exists in destination
|
|
if (!fs::exists(destPath)) {
|
|
fs::create_directories(destPath);
|
|
}
|
|
} else if (entry.is_regular_file()) {
|
|
// Ensure parent directory exists
|
|
fs::create_directories(destPath.parent_path());
|
|
|
|
if (!fs::exists(destPath)) {
|
|
fs::copy_file(sourcePath, destPath);
|
|
}
|
|
else if (fs::last_write_time(sourcePath) > fs::last_write_time(destPath)) {
|
|
fs::copy_file(sourcePath, destPath, fs::copy_options::overwrite_existing);
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Handle regular file
|
|
if (!fs::exists(destination)) {
|
|
fs::copy_file(additionalFile, destination);
|
|
}
|
|
else if (fs::last_write_time(additionalFile) > fs::last_write_time(destination)) {
|
|
fs::copy_file(additionalFile, destination, fs::copy_options::overwrite_existing);
|
|
}
|
|
}
|
|
}
|
|
} catch(std::exception& e) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = e.what();
|
|
}
|
|
}
|
|
});
|
|
|
|
std::vector<ExternalBuildResult> externalResults(config.externalDependencies.size());
|
|
std::vector<std::thread> externalThreads;
|
|
externalThreads.reserve(config.externalDependencies.size());
|
|
for (std::size_t i = 0; i < config.externalDependencies.size(); ++i) {
|
|
externalThreads.emplace_back([&, i]() {
|
|
Progress::Task task(std::format("Building external dep {}", config.externalDependencies[i].name));
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
externalResults[i] = BuildExternal(config.externalDependencies[i], config.target, buildCancelled);
|
|
if (!externalResults[i].error.empty()) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = externalResults[i].error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
fs::path stdPcmDir = GetCacheDir()/(config.target+"-"+config.march);
|
|
|
|
if (!fs::exists(stdPcmDir)) {
|
|
fs::create_directories(stdPcmDir);
|
|
}
|
|
|
|
std::string stdPcmResult;
|
|
{
|
|
Progress::Task task(std::format("Building std PCM ({}-{})", config.target, config.march));
|
|
stdPcmResult = BuildStdPcm(config, stdPcmDir/"std.pcm");
|
|
}
|
|
if(!stdPcmResult.empty()) {
|
|
buildCancelled.store(true);
|
|
for(std::thread& thread : threads) thread.join();
|
|
for(std::thread& thread : externalThreads) thread.join();
|
|
return {stdPcmResult, false, {}};
|
|
}
|
|
|
|
fs::path pcmDir;
|
|
|
|
if(config.type != ConfigurationType::Executable) {
|
|
pcmDir = outputDir;
|
|
} else {
|
|
pcmDir = buildDir;
|
|
}
|
|
|
|
fs::copy_file(stdPcmDir/"std.pcm", pcmDir/"std.pcm", fs::copy_options::update_existing);
|
|
|
|
std::string editedTarget = config.target;
|
|
std::replace(editedTarget.begin(), editedTarget.end(), '-', '_');
|
|
|
|
// wasm32 targets reject -march and silently ignore -mtune (clang errors on
|
|
// the former). Skip both for any wasm32-* triple.
|
|
bool isWasm = config.target.starts_with("wasm32");
|
|
std::string archFlags = isWasm
|
|
? std::string()
|
|
: std::format(" -march={} -mtune={}", config.march, config.mtune);
|
|
std::string command = std::format("{} --target={}{} -std=c++26 -D CRAFTER_BUILD_CONFIGURATION_TARGET=\\\"{}\\\" -D CRAFTER_BUILD_CONFIGURATION_TARGET_{} -fprebuilt-module-path={} -fprebuilt-module-path={}", GetBaseCommand(config), config.target, archFlags, editedTarget, editedTarget, stdPcmDir.string(), pcmDir.string());
|
|
|
|
if (!config.sysroot.empty()) {
|
|
command += std::format(" --sysroot={}", config.sysroot);
|
|
}
|
|
if (config.target.starts_with("wasm32")) {
|
|
// -mllvm is consumed by codegen but not the link driver, which is the
|
|
// same command line; quiet the unused-flag warning rather than split
|
|
// compile and link commands.
|
|
command += " -fno-exceptions -fno-c++-static-destructors -mllvm -wasm-enable-sjlj -D_WASI_EMULATED_SIGNAL -Wno-unused-command-line-argument";
|
|
}
|
|
if (config.target == "x86_64-w64-mingw32") {
|
|
// mingw libstdc++ defines TLS via __emutls_v.* (emulated TLS); without
|
|
// -femulated-tls clang generates native-TLS references that don't
|
|
// match. Symptom: undefined std::__once_callable / __once_call at
|
|
// link time. Also -Wno-unused… because -femulated-tls is a codegen
|
|
// flag the link driver doesn't consume.
|
|
command += " -femulated-tls -Wno-unused-command-line-argument";
|
|
}
|
|
|
|
if(config.type == ConfigurationType::LibraryDynamic) {
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
|
command += " -fPIC -D CRAFTER_BUILD_CONFIGURATION_TYPE_SHARED_LIBRARY";
|
|
#endif
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_SHARED_LIBRARY";
|
|
#endif
|
|
} else if(config.type == ConfigurationType::Executable) {
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_EXECUTABLE";
|
|
// On Windows targets the API uses __declspec(dllimport) when consuming
|
|
// a DLL. Set the macro for executables so CRAFTER_API resolves to
|
|
// dllimport in their PCM cache (separate from the lib's PCM cache,
|
|
// which gets dllexport). Harmless if the exe doesn't actually link a
|
|
// crafter DLL — CRAFTER_API only matters at API call sites.
|
|
if (config.target == "x86_64-w64-mingw32" || config.target == "x86_64-pc-windows-msvc") {
|
|
command += " -D CRAFTER_BUILD_DLL_IMPORT";
|
|
}
|
|
} else {
|
|
command += " -D CRAFTER_BUILD_CONFIGURATION_TYPE_LIBRARY";
|
|
}
|
|
|
|
std::string files;
|
|
std::unordered_set<std::string> libSet;
|
|
std::mutex fileMutex;
|
|
std::vector<std::thread> depThreads;
|
|
depThreads.reserve(config.dependencies.size());
|
|
std::atomic<bool> repack(false);
|
|
|
|
{
|
|
std::unordered_set<Configuration*> seen;
|
|
std::function<void(Configuration*)> addFlags = [&](Configuration* dep) {
|
|
if (!seen.insert(dep).second) return;
|
|
for (const auto& entry : fs::recursive_directory_iterator(dep->path)) {
|
|
if (entry.is_directory() && entry.path().filename() == "include") {
|
|
command += " -I" + entry.path().string();
|
|
}
|
|
}
|
|
command += std::format(" -I{} -fprebuilt-module-path={}", dep->path.string(), dep->PcmDir().string());
|
|
for (Configuration* sub : dep->dependencies) {
|
|
addFlags(sub);
|
|
}
|
|
};
|
|
for (Configuration* dep : config.dependencies) {
|
|
addFlags(dep);
|
|
}
|
|
}
|
|
|
|
for(Configuration* dep : config.dependencies) {
|
|
depThreads.emplace_back([&, dep](){
|
|
try {
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
|
|
std::shared_ptr<std::promise<BuildResult>> promise;
|
|
std::shared_future<BuildResult> resultFuture;
|
|
bool isBuilder = false;
|
|
|
|
depMutex.lock();
|
|
fs::path cacheKey = dep->PcmDir();
|
|
auto it = depResults.find(cacheKey);
|
|
if (it == depResults.end()) {
|
|
isBuilder = true;
|
|
promise = std::make_shared<std::promise<BuildResult>>();
|
|
resultFuture = promise->get_future().share();
|
|
depResults.emplace(cacheKey, resultFuture);
|
|
} else {
|
|
resultFuture = it->second;
|
|
}
|
|
depMutex.unlock();
|
|
|
|
if (isBuilder) {
|
|
BuildResult built;
|
|
try {
|
|
built = Build(*dep, depResults, depMutex);
|
|
} catch (...) {
|
|
promise->set_exception(std::current_exception());
|
|
throw;
|
|
}
|
|
promise->set_value(std::move(built));
|
|
}
|
|
|
|
const BuildResult& result = resultFuture.get();
|
|
fileMutex.lock();
|
|
for (const std::string& lib : result.libs) libSet.insert(lib);
|
|
fileMutex.unlock();
|
|
if (!result.result.empty()) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = result.result;
|
|
}
|
|
}
|
|
if (result.repack) {
|
|
repack = true;
|
|
}
|
|
} catch (const std::exception& e) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::format("dep build for {} threw: {}", dep->path.string(), e.what());
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
for(const Define& define : config.defines) {
|
|
if(define.value.empty()) {
|
|
command += std::format(" -D {}", define.name);
|
|
} else {
|
|
command += std::format(" -D {}={}", define.name, define.value);
|
|
}
|
|
}
|
|
|
|
for(const std::string& flag : config.compileFlags) {
|
|
command += " " + flag;
|
|
}
|
|
|
|
std::string cmakeBuildType;
|
|
|
|
if(config.debug) {
|
|
cmakeBuildType = "Debug";
|
|
command += " -g -D CRAFTER_BUILD_CONFIGURATION_DEBUG";
|
|
} else {
|
|
cmakeBuildType = "Release";
|
|
command += " -O3";
|
|
}
|
|
|
|
for (const fs::path& cFile : config.cFiles) {
|
|
files += std::format(" {}_source.o ", (buildDir / cFile.filename()).string());
|
|
const std::string objPath = (buildDir / cFile.filename()).string() + "_source.o";
|
|
const std::string srcPath = cFile.string() + ".c";
|
|
if (!fs::exists(objPath) || fs::last_write_time(srcPath) > fs::last_write_time(objPath)) {
|
|
threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled, &config]() {
|
|
Progress::Task task(std::format("Compiling {}.c", cFile.filename().string()));
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
|
|
std::string result = RunCommand(std::format("clang {}.c --target={} -march={} -mtune={} -O3 -c -o {}_source.o", cFile.string(), config.target, config.march, config.mtune, (buildDir / cFile.filename()).string()));
|
|
if (result.empty()) return;
|
|
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::move(result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
for (const fs::path& cFile : config.cuda) {
|
|
files += std::format(" {}_source.o ", (buildDir / cFile.filename()).string());
|
|
const std::string objPath = (buildDir / cFile.filename()).string() + "_source.o";
|
|
const std::string srcPath = cFile.string() + ".cu";
|
|
if (!fs::exists(objPath) || fs::last_write_time(srcPath) > fs::last_write_time(objPath)) {
|
|
threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled]() {
|
|
Progress::Task task(std::format("Compiling {}.cu", cFile.filename().string()));
|
|
if (buildCancelled.load(std::memory_order_relaxed)) return;
|
|
|
|
std::string result = RunCommand(std::format("nvcc {}.cu -c -o {}_source.o -O3 -arch=sm_89", cFile.string(), (buildDir / cFile.filename()).string()));
|
|
if (result.empty()) return;
|
|
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::move(result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
for(std::thread& thread : depThreads) {
|
|
thread.join();
|
|
}
|
|
for(std::thread& thread : externalThreads) {
|
|
thread.join();
|
|
}
|
|
|
|
if(buildCancelled.load()) {
|
|
for(std::thread& thread : threads) thread.join();
|
|
return {buildError, false, {}};
|
|
}
|
|
|
|
if(repack.load()) {
|
|
buildResult.repack = true;
|
|
}
|
|
buildResult.libs = std::move(libSet);
|
|
for(const std::string& flag : config.linkFlags) {
|
|
buildResult.libs.insert(flag);
|
|
}
|
|
fs::file_time_type externalFloor = fs::file_time_type::min();
|
|
for(const ExternalBuildResult& ext : externalResults) {
|
|
for(const std::string& flag : ext.compileFlags) {
|
|
command += " " + flag;
|
|
}
|
|
for(const std::string& flag : ext.linkFlags) {
|
|
buildResult.libs.insert(flag);
|
|
}
|
|
if (ext.latestArtifact > externalFloor) externalFloor = ext.latestArtifact;
|
|
}
|
|
|
|
for(std::unique_ptr<Module>& interface : config.interfaces) {
|
|
if(interface->Check(pcmDir, externalFloor)) {
|
|
Module* mod = interface.get();
|
|
threads.emplace_back([mod, &command, &pcmDir, &buildDir, &buildCancelled, &buildError]() {
|
|
Progress::Task task(std::format("Compiling interface {}", mod->path.filename().string()));
|
|
try {
|
|
mod->Compile(command, pcmDir, buildDir, buildCancelled, buildError);
|
|
} catch (const std::exception& e) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::format("Module::Compile threw: {}", e.what());
|
|
}
|
|
}
|
|
});
|
|
buildResult.repack = true;
|
|
}
|
|
files += std::format(" {}/{}.o", buildDir.string(), interface->path.filename().string());
|
|
for(std::unique_ptr<ModulePartition>& part : interface->partitions) {
|
|
files += std::format(" {}/{}.o", buildDir.string(), part->path.filename().string());
|
|
}
|
|
}
|
|
|
|
for(Implementation& implementation : config.implementations) {
|
|
if(implementation.Check(buildDir, pcmDir, externalFloor)) {
|
|
buildResult.repack = true;
|
|
Implementation* impl = &implementation;
|
|
threads.emplace_back([impl, &command, &buildDir, &buildCancelled, &buildError]() {
|
|
Progress::Task task(std::format("Compiling {}.cpp", impl->path.filename().string()));
|
|
try {
|
|
impl->Compile(command, buildDir, buildCancelled, buildError);
|
|
} catch (const std::exception& e) {
|
|
bool expected = false;
|
|
if (buildCancelled.compare_exchange_strong(expected, true)) {
|
|
buildError = std::format("Implementation::Compile threw: {}", e.what());
|
|
}
|
|
}
|
|
});
|
|
}
|
|
files += std::format(" {}/{}_impl.o", buildDir.string(), implementation.path.filename().string());
|
|
}
|
|
|
|
for(std::thread& thread : threads) {
|
|
thread.join();
|
|
}
|
|
|
|
if(buildCancelled.load()) {
|
|
return {buildError, false, {}};
|
|
}
|
|
|
|
std::string linkExtras;
|
|
for(const std::string& flag : buildResult.libs) {
|
|
linkExtras += " " + flag;
|
|
}
|
|
// mingw uses libstdc++; C++26 std::print/format extras live in libstdc++exp.
|
|
// libstdc++ on mingw uses winpthreads for std::atomic_wait /
|
|
// counting_semaphore / stop_token, so -lpthread is required as soon as
|
|
// those primitives appear (they do, transitively, in any non-trivial std
|
|
// import). -static-libstdc++ bundles libstdc++ into the exe so we don't
|
|
// chase libstdc++-6.dll TLS symbol mismatches across mingw versions and
|
|
// the resulting binary stands alone. Auto-link so user projects don't
|
|
// carry boilerplate.
|
|
if (config.target == "x86_64-w64-mingw32") {
|
|
// Static-link libstdc++/libgcc/libwinpthread so the resulting .exe
|
|
// or .dll doesn't depend on a specific runtime DLL being on the
|
|
// consumer's PATH. The mingw runtime ABI varies subtly between
|
|
// distributions (Arch UCRT vs msys2 UCRT vs msys2 MSVCRT) and
|
|
// STATUS_ENTRYPOINT_NOT_FOUND at LoadLibrary time is the symptom
|
|
// of a mismatch. Static linkage trades binary size for portability.
|
|
// The -Bstatic/-Bdynamic bracketing forces -lpthread to resolve
|
|
// against libwinpthread.a rather than the import lib; everything
|
|
// else (KERNEL32, UCRT) stays dynamic. -lstdc++exp adds C++26
|
|
// std::print/format extras. -femulated-tls is already on the
|
|
// compile so __once_callable et al resolve in static libstdc++.
|
|
linkExtras += " -lstdc++exp -static-libstdc++ -static-libgcc -Wl,-Bstatic -lpthread -Wl,-Bdynamic";
|
|
}
|
|
|
|
// Force a relink if the expected output is missing or older than any dep
|
|
// artifact. Missing covers: previous build produced a different outputName,
|
|
// or the binary was deleted by hand. Older-than-dep covers: dep's library
|
|
// was rebuilt by an earlier run (so dep.repack is false this time around)
|
|
// but the consumer was never relinked against the new dep.
|
|
{
|
|
auto expectedOutputFor = [](const Configuration& c) -> fs::path {
|
|
fs::path dir = c.path/"bin"/std::format("{}-{}-{}", c.name, c.target, c.march);
|
|
if (c.type == ConfigurationType::Executable) {
|
|
if (c.target.starts_with("wasm32"))
|
|
return dir / (c.outputName + ".wasm");
|
|
return c.target == "x86_64-w64-mingw32"
|
|
? dir / (c.outputName + ".exe")
|
|
: dir / c.outputName;
|
|
}
|
|
if (c.type == ConfigurationType::LibraryStatic) {
|
|
return c.target == "x86_64-w64-mingw32" || c.target == "x86_64-pc-windows-msvc"
|
|
? dir / std::format("{}.lib", c.outputName)
|
|
: dir / std::format("lib{}.a", c.outputName);
|
|
}
|
|
// LibraryDynamic — point at the .dll on Windows targets so the
|
|
// mtime check sees the newly-built DLL; on Unix the .so suffices.
|
|
if (c.target == "x86_64-w64-mingw32" || c.target == "x86_64-pc-windows-msvc") {
|
|
return dir / std::format("{}.dll", c.outputName);
|
|
}
|
|
return dir / std::format("lib{}.so", c.outputName);
|
|
};
|
|
|
|
fs::path expected = expectedOutputFor(config);
|
|
if (!fs::exists(expected)) {
|
|
buildResult.repack = true;
|
|
} else {
|
|
auto consumerMtime = fs::last_write_time(expected);
|
|
for (Configuration* dep : config.dependencies) {
|
|
fs::path depArtifact = expectedOutputFor(*dep);
|
|
if (fs::exists(depArtifact) && fs::last_write_time(depArtifact) > consumerMtime) {
|
|
buildResult.repack = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(buildResult.repack) {
|
|
Progress::Task task(std::format("Linking {}", config.outputName));
|
|
if(config.type == ConfigurationType::Executable) {
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
|
if(config.target == "x86_64-w64-mingw32") {
|
|
try {
|
|
// Copy any LibraryDynamic dependency DLLs alongside
|
|
// the launcher exe — Windows resolves DLLs from the exe's
|
|
// own directory at load time, so this is the simplest
|
|
// equivalent of rpath $ORIGIN.
|
|
std::unordered_set<Configuration*> dllSeen;
|
|
std::function<void(Configuration*)> copyDepDlls = [&](Configuration* dep) {
|
|
if (!dllSeen.insert(dep).second) return;
|
|
if (dep->type == ConfigurationType::LibraryDynamic && dep->target == "x86_64-w64-mingw32") {
|
|
fs::path depDir = dep->path / "bin" / std::format("{}-{}-{}", dep->name, dep->target, dep->march);
|
|
// The DLL itself (Windows resolves it from the
|
|
// exe's directory at load time) and the mingw
|
|
// import lib (so a downstream `crafter-build.exe`
|
|
// can link a fresh project.dll against it without
|
|
// hunting through sibling output dirs).
|
|
for (auto fname : {std::format("{}.dll", dep->outputName),
|
|
std::format("lib{}.dll.a", dep->outputName)}) {
|
|
fs::path src = depDir / fname;
|
|
if (!fs::exists(src)) continue;
|
|
fs::path dest = outputDir / src.filename();
|
|
if (!fs::exists(dest) || fs::last_write_time(src) > fs::last_write_time(dest)) {
|
|
fs::copy(src, dest, fs::copy_options::overwrite_existing);
|
|
}
|
|
}
|
|
}
|
|
for (Configuration* sub : dep->dependencies) copyDepDlls(sub);
|
|
};
|
|
for (Configuration* dep : config.dependencies) copyDepDlls(dep);
|
|
} catch (const fs::filesystem_error& e) {
|
|
return {e.what(), false, {}};
|
|
}
|
|
}
|
|
if (config.target.starts_with("wasm32")) {
|
|
buildResult.result = RunCommand(std::format("{}{} -o {}.wasm -fuse-ld=lld{}", command, files, (outputDir/config.outputName).string(), linkExtras));
|
|
} else {
|
|
buildResult.result = RunCommand(std::format("{}{} -o {} -fuse-ld=lld{}", command, files, (outputDir/config.outputName).string(), linkExtras));
|
|
}
|
|
#endif
|
|
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
|
if (config.target == "x86_64-w64-mingw32") {
|
|
// Windows host, mingw target: same shape as the Linux→mingw
|
|
// path (no LIBCXX_DIR / -lc++ / -nostdlib++ — those are MSVC
|
|
// libc++ flags). Copy LibraryDynamic dep DLLs + import libs
|
|
// alongside the launcher exe so Windows resolves them from
|
|
// the exe's own directory at load time. Runtime DLLs (libstdc++,
|
|
// libgcc, libwinpthread) come from msys2 on PATH.
|
|
std::unordered_set<Configuration*> dllSeen;
|
|
std::function<void(Configuration*)> copyDepDlls = [&](Configuration* dep) {
|
|
if (!dllSeen.insert(dep).second) return;
|
|
if (dep->type == ConfigurationType::LibraryDynamic && dep->target == "x86_64-w64-mingw32") {
|
|
fs::path depDir = dep->path / "bin" / std::format("{}-{}-{}", dep->name, dep->target, dep->march);
|
|
for (auto fname : {std::format("{}.dll", dep->outputName),
|
|
std::format("lib{}.dll.a", dep->outputName)}) {
|
|
fs::path src = depDir / fname;
|
|
if (!fs::exists(src)) continue;
|
|
fs::path dest = outputDir / src.filename();
|
|
if (!fs::exists(dest) || fs::last_write_time(src) > fs::last_write_time(dest)) {
|
|
fs::copy(src, dest, fs::copy_options::overwrite_existing);
|
|
}
|
|
}
|
|
}
|
|
for (Configuration* sub : dep->dependencies) copyDepDlls(sub);
|
|
};
|
|
for (Configuration* dep : config.dependencies) copyDepDlls(dep);
|
|
|
|
buildResult.result = RunCommand(std::format(
|
|
"{}{} -o {} -fuse-ld=lld{}",
|
|
command, files, (outputDir/config.outputName).string(), linkExtras));
|
|
} else {
|
|
std::system(std::format("copy \"%LIBCXX_DIR%\\lib\\c++.dll\" \"{}\\c++.dll\"", outputDir.string()).c_str());
|
|
buildResult.result = RunCommand(std::format("{}{} -o {}.exe -fuse-ld=lld -L %LIBCXX_DIR%\\lib -lc++ -nostdinc++ -nostdlib++{}", command, files, (outputDir/config.outputName).string(), linkExtras));
|
|
}
|
|
#endif
|
|
} else if(config.type == ConfigurationType::LibraryStatic) {
|
|
#ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
|
|
buildResult.result = RunCommand(std::format("ar rcs {}.a {}", (outputDir/fs::path(std::string("lib")+config.outputName)).string(), files));
|
|
#endif
|
|
|
|
#if defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_windows_msvc) || defined(CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_w64_mingw32)
|
|
buildResult.result = RunCommand(std::format("llvm-lib.exe {} /OUT:{}.lib", files, (outputDir/fs::path(config.outputName)).string()));
|
|
#endif
|
|
} else {
|
|
// LibraryDynamic. Output names follow each target's convention so
|
|
// consumers can link via the standard linker search:
|
|
// mingw: <name>.dll + lib<name>.dll.a (lld --out-implib)
|
|
// msvc: <name>.dll + <name>.lib (lld /IMPLIB)
|
|
// unix: lib<name>.so (rpath $ORIGIN)
|
|
if (config.target == "x86_64-w64-mingw32") {
|
|
fs::path dll = outputDir / std::format("{}.dll", config.outputName);
|
|
fs::path implib = outputDir / std::format("lib{}.dll.a", config.outputName);
|
|
buildResult.result = RunCommand(std::format(
|
|
"{}{} -shared -o {} -Wl,--out-implib,{} -fuse-ld=lld{}",
|
|
command, files, dll.string(), implib.string(), linkExtras));
|
|
} else if (config.target == "x86_64-pc-windows-msvc") {
|
|
fs::path dll = outputDir / std::format("{}.dll", config.outputName);
|
|
fs::path implib = outputDir / std::format("{}.lib", config.outputName);
|
|
buildResult.result = RunCommand(std::format(
|
|
"{}{} -shared -o {} -Wl,/IMPLIB:{} -fuse-ld=lld{}",
|
|
command, files, dll.string(), implib.string(), linkExtras));
|
|
} else {
|
|
buildResult.result = RunCommand(std::format(
|
|
"{}{} -shared -o {}.so -Wl,-rpath,'$ORIGIN' -fuse-ld=lld{}",
|
|
command, files, (outputDir/(std::string("lib")+config.outputName)).string(), linkExtras));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (config.type == ConfigurationType::LibraryStatic || config.type == ConfigurationType::LibraryDynamic) {
|
|
buildResult.libs.insert(std::format("-L{}", outputDir.string()));
|
|
buildResult.libs.insert(std::format("-l{}", config.outputName));
|
|
}
|
|
|
|
return buildResult;
|
|
}
|
|
|
|
void Crafter::EnableWasiBrowserRuntime(Configuration& cfg) {
|
|
fs::path runtimeDir = GetCrafterBuildHome() / "wasi-runtime";
|
|
fs::path runtimeJs = runtimeDir / "runtime.js";
|
|
fs::path htmlTemplate = runtimeDir / "index.html.in";
|
|
if (!fs::exists(runtimeJs) || !fs::exists(htmlTemplate)) {
|
|
throw std::runtime_error(std::format(
|
|
"wasi-runtime assets missing under {} (set CRAFTER_BUILD_HOME or reinstall)",
|
|
runtimeDir.string()));
|
|
}
|
|
|
|
fs::path htmlOutDir = cfg.path / "build" / "wasi-runtime" / cfg.name;
|
|
fs::create_directories(htmlOutDir);
|
|
fs::path htmlPath = htmlOutDir / "index.html";
|
|
|
|
std::ifstream in(htmlTemplate);
|
|
std::stringstream buf;
|
|
buf << in.rdbuf();
|
|
std::string html = std::regex_replace(buf.str(), std::regex(R"(\{\{WASM\}\})"), cfg.outputName + ".wasm");
|
|
std::ofstream out(htmlPath);
|
|
out << html;
|
|
out.close();
|
|
|
|
cfg.files.push_back(runtimeJs);
|
|
cfg.files.push_back(htmlPath);
|
|
}
|
|
|
|
std::string Crafter::HostTarget() {
|
|
static const std::string cached = []() -> std::string {
|
|
CommandResult r = RunCommandChecked("clang++ -print-target-triple");
|
|
if (r.exitCode != 0) return {};
|
|
std::string out = std::move(r.output);
|
|
while (!out.empty() && (out.back() == '\n' || out.back() == '\r')) out.pop_back();
|
|
return out;
|
|
}();
|
|
return cached;
|
|
}
|
|
|
|
void Crafter::ApplyStandardArgs(Configuration& cfg, std::span<const std::string_view> args) {
|
|
if (const char* envMarch = std::getenv("CRAFTER_BUILD_MARCH"); envMarch && *envMarch) {
|
|
cfg.march = envMarch;
|
|
}
|
|
if (const char* envMtune = std::getenv("CRAFTER_BUILD_MTUNE"); envMtune && *envMtune) {
|
|
cfg.mtune = envMtune;
|
|
}
|
|
for (std::string_view a : args) {
|
|
if (a == "--debug") cfg.debug = true;
|
|
else if (a.starts_with("--target=")) cfg.target = std::string(a.substr(std::string_view("--target=").size()));
|
|
else if (a.starts_with("--march=")) cfg.march = std::string(a.substr(std::string_view("--march=").size()));
|
|
else if (a.starts_with("--mtune=")) cfg.mtune = std::string(a.substr(std::string_view("--mtune=").size()));
|
|
}
|
|
}
|
|
|
|
static void PrintHelp(std::string_view argv0) {
|
|
std::println(
|
|
R"(Usage:
|
|
{0} [options] [-- project-args...] Build the project in the current directory
|
|
{0} test [test-options] [globs...] Build and run the project's tests
|
|
{0} help | -h | --help Show this help
|
|
|
|
Loads ./project.cpp (override with --project=<path>), compiles it to a shared
|
|
object, and invokes its CrafterBuildProject() to obtain a Configuration that
|
|
drives the build. Outputs land at bin/<name>-<target>-<march>/, intermediates
|
|
at build/<name>-<target>-<march>/.
|
|
|
|
Build options:
|
|
-r Run the produced executable after a successful build
|
|
(host targets only; libraries cannot be run).
|
|
-v, --verbose Verbose progress output.
|
|
-q, --quiet Suppress progress output.
|
|
--project=<path> Path to the project file (default: ./project.cpp).
|
|
|
|
Test options (after the `test` subcommand):
|
|
--list Enumerate matching tests without running them.
|
|
--jobs=<N> Parallel job count (default: hardware_concurrency).
|
|
--timeout=<seconds> Per-test timeout override.
|
|
--runner=<spec> Override the test runner for this run. Specs:
|
|
local
|
|
cmd:<command> (e.g. cmd:wine)
|
|
ssh:<host>[:<remoteDir>]
|
|
sshwin:<host>[:<remoteDir>]
|
|
wsl[:<remoteDir>]
|
|
--target=<triple> Filter to tests whose cfg.target matches; this is
|
|
also forwarded to project-args so per-target tests
|
|
build for that triple. Default: host triple.
|
|
<glob> One or more name globs to filter tests (e.g. 'Unit*').
|
|
|
|
Project args:
|
|
Any flag not consumed above is forwarded verbatim to CrafterBuildProject as
|
|
part of its `args` span. Project-specific flags (e.g. --target=, custom
|
|
feature toggles) live there.
|
|
|
|
Environment:
|
|
CRAFTER_BUILD_MARCH Override -march (default: native).
|
|
CRAFTER_BUILD_MTUNE Override -mtune (default: native).
|
|
CRAFTER_BUILD_RUNNER_<TARGET> Default test runner for a target triple.
|
|
Replace '-' and '.' with '_' in the
|
|
triple. CLI --runner= overrides this.
|
|
CRAFTER_MINGW_DIR Override mingw-w64 sysroot auto-detect.
|
|
LIBCXX_DIR Windows libc++ install (MSVC ABI builds).
|
|
|
|
Exit status:
|
|
0 success / all non-skipped tests passed
|
|
1 build failure or one or more tests failed
|
|
)", argv0);
|
|
}
|
|
|
|
int Crafter::Run(int argc, char** argv) {
|
|
try {
|
|
std::string_view argv0 = argc > 0 ? argv[0] : "crafter-build";
|
|
fs::path projectFile = "./project.cpp";
|
|
std::vector<std::string_view> projectArgs;
|
|
projectArgs.reserve(argc);
|
|
|
|
bool runTests = false;
|
|
bool runAfterBuild = false;
|
|
RunTestsOptions testOpts;
|
|
Progress::Verbosity verbosity = Progress::Verbosity::Default;
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
std::string_view arg = argv[i];
|
|
if (arg == "-h" || arg == "--help" || (!runTests && arg == "help")) {
|
|
PrintHelp(argv0);
|
|
return 0;
|
|
} else if (arg == "test") {
|
|
runTests = true;
|
|
} else if (arg == "-r") {
|
|
runAfterBuild = true;
|
|
} else if (arg == "-v" || arg == "--verbose") {
|
|
verbosity = Progress::Verbosity::Verbose;
|
|
} else if (arg == "-q" || arg == "--quiet") {
|
|
verbosity = Progress::Verbosity::Quiet;
|
|
} else if (arg.starts_with("--project=")) {
|
|
projectFile = arg.substr(std::string_view("--project=").size());
|
|
} else if (runTests && arg.starts_with("--jobs=")) {
|
|
testOpts.jobs = std::stoi(std::string(arg.substr(std::string_view("--jobs=").size())));
|
|
} else if (runTests && arg.starts_with("--timeout=")) {
|
|
testOpts.timeoutOverride = std::chrono::seconds(std::stoi(std::string(arg.substr(std::string_view("--timeout=").size()))));
|
|
} else if (runTests && arg == "--list") {
|
|
testOpts.listOnly = true;
|
|
} else if (runTests && arg.starts_with("--runner=")) {
|
|
testOpts.runnerOverride = std::string(arg.substr(std::string_view("--runner=").size()));
|
|
} else if (runTests && !arg.starts_with("-")) {
|
|
testOpts.globs.emplace_back(arg);
|
|
} else {
|
|
projectArgs.push_back(arg);
|
|
}
|
|
}
|
|
|
|
Progress::SetVerbosity(verbosity);
|
|
|
|
// The test run is target-scoped: only tests whose cfg.target equals
|
|
// testOpts.targetFilter are included. Default = host triple, so a
|
|
// bare `crafter-build test` runs everything that targets host.
|
|
for (auto& a : projectArgs) {
|
|
if (a.starts_with("--target=")) {
|
|
testOpts.targetFilter = std::string(a.substr(std::string_view("--target=").size()));
|
|
}
|
|
}
|
|
|
|
if (!fs::exists(projectFile)) {
|
|
std::println(std::cerr, "No project file at {}", projectFile.string());
|
|
return 1;
|
|
}
|
|
|
|
Configuration config = LoadProject(projectFile, projectArgs);
|
|
SetParentProject(&config);
|
|
|
|
if (runTests) {
|
|
TestSummary summary = RunTests(config, testOpts, projectArgs);
|
|
return summary.AllPassed() ? 0 : 1;
|
|
}
|
|
|
|
std::unordered_map<fs::path, std::shared_future<BuildResult>> depResults;
|
|
std::mutex depMutex;
|
|
BuildResult result = Build(config, depResults, depMutex);
|
|
|
|
if (!result.result.empty()) {
|
|
Progress::Clear();
|
|
std::println(std::cerr, "{}", result.result);
|
|
return 1;
|
|
}
|
|
|
|
Progress::Finalize();
|
|
|
|
if (runAfterBuild) {
|
|
if (config.type != ConfigurationType::Executable) {
|
|
std::println(std::cerr, "-r: cannot run a library");
|
|
return 1;
|
|
}
|
|
fs::path dir = config.path / "bin" / std::format("{}-{}-{}", config.name, config.target, config.march);
|
|
fs::path artifact = dir / config.outputName;
|
|
if (config.target.starts_with("wasm32")) {
|
|
artifact += ".wasm";
|
|
} else if (config.target == "x86_64-w64-mingw32" || config.target == "x86_64-pc-windows-msvc") {
|
|
artifact += ".exe";
|
|
}
|
|
// Resolve to absolute — cmd.exe on Windows mishandles a leading
|
|
// "./" by trying to interpret it as a command. system() invokes
|
|
// through cmd /c, so the relative-prefixed path makes cmd error
|
|
// with "'.' is not recognized as an internal or external command".
|
|
artifact = fs::absolute(artifact);
|
|
return std::system(artifact.string().c_str()) == 0 ? 0 : 1;
|
|
}
|
|
|
|
return 0;
|
|
} catch (const std::exception& e) {
|
|
Progress::Clear();
|
|
std::println(std::cerr, "{}", e.what());
|
|
return 1;
|
|
}
|
|
}
|