Crafter.Build/interfaces/Crafter.Build-Clang.cppm

/*
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;
#include "Crafter.Build-Api.h"
export module Crafter.Build:Clang;
import std;
import :Shader;
import :Interface;
import :Implementation;
import :External;
namespace fs = std::filesystem;

export namespace Crafter {
    struct BuildResult {
        std::string result;
        bool repack;
        std::unordered_set<std::string> libs;
    };

    struct Define {
        std::string name;
        std::string value;
    };

    enum class ConfigurationType {
        Executable,
        LibraryStatic,
        LibraryDynamic,
    };

    struct Test;

    struct TestRunner {
        // Quoting style for {args} when this runner is used. Args reach
        // whichever shell the runner ultimately delivers them to: Host for
        // Local + Cmd-prefix (host shell parses), Sh for Ssh (remote bash),
        // Cmd for SshWin (remote cmd.exe).
        enum class Shell { Host, Sh, Cmd };

        std::string copy;
        std::string exec;
        std::string cleanup;
        std::string remoteDir;
        std::string name;
        // Runs once per RunTests invocation (cached by `name`). Exit 0 = runner
        // is available; non-zero = skip every Test using this runner with a
        // "runner unavailable" message. Empty = always available (e.g., Local).
        std::string probe;
        Shell argsShell = Shell::Host;

        bool IsLocal() const { return exec.empty(); }

        static CRAFTER_API TestRunner Local();
        static CRAFTER_API TestRunner Ssh(std::string host, std::string remoteDir = "/tmp/crafter-tests");
        static CRAFTER_API TestRunner SshWin(std::string host, std::string remoteDir = "C:/temp/crafter-tests");
        static CRAFTER_API TestRunner Wsl(std::string remoteDir = "/tmp/crafter-tests-wsl");
        static CRAFTER_API TestRunner Cmd(std::string command);
        static CRAFTER_API std::optional<TestRunner> FromSpec(std::string_view spec);
        static CRAFTER_API TestRunner FromEnv(std::string_view target, TestRunner fallback = Local());
    };

    enum class TestOutcome { Pass, Fail, Crash, Timeout, Skipped };

    struct TestResult {
        std::string name;
        TestOutcome outcome = TestOutcome::Pass;
        int exitCode = 0;
        int signal = 0;
        std::chrono::milliseconds duration{0};
        std::string output;
    };

    // The host target triple, detected once per process by running
    // `clang++ -print-target-triple` and cached. Used as the default for
    // Configuration::target so projects don't have to hardcode it for the
    // no-cross-compile case. Returns "" if clang isn't on PATH or doesn't
    // print a triple — those projects still need an explicit cfg.target.
    CRAFTER_API std::string HostTarget();

    struct Configuration {
        fs::path path;
        std::string outputName;
        std::string name;
        std::string march = "native";
        std::string mtune = "native";
        std::string target = HostTarget();
        std::string sysroot;
        bool debug = false;
        ConfigurationType type = ConfigurationType::Executable;
        std::vector<std::unique_ptr<Module>> interfaces;
        std::vector<Implementation> implementations;
        std::vector<fs::path> cFiles;
        std::vector<fs::path> cuda;
        std::vector<Configuration*> dependencies;
        std::vector<fs::path> files;
        std::vector<Define> defines;
        std::vector<Shader> shaders;
        std::vector<ExternalDependency> externalDependencies;
        std::vector<std::string> compileFlags;
        std::vector<std::string> linkFlags;
        std::vector<Test> tests;
        CRAFTER_API void GetInterfacesAndImplementations(std::span<fs::path> interfaces, std::span<fs::path> implementations);
        fs::path PcmDir() const {
            return path
                / (type == ConfigurationType::Executable ? "build" : "bin")
                / std::format("{}-{}-{}", name, target, march);
        }
    };

    struct Test {
        Configuration config;
        TestRunner runner;
        std::chrono::seconds timeout{60};
        std::vector<std::string> args;
    };

    CRAFTER_API BuildResult Build(Configuration& config, std::unordered_map<fs::path, std::shared_future<BuildResult>>& depResults, std::mutex& depMutex);

    CRAFTER_API int Run(int argc, char** argv);

    // Add a small index.html + runtime.js pair next to the .wasm output so the
    // build can be loaded directly in a browser (just `serve` the bin dir and
    // open it). Opt-in: WASI builds destined for wasmtime/wasmer don't need
    // this and shouldn't carry the extra files. Call from project.cpp after
    // outputName is set; index.html is generated against the current
    // outputName so renaming the binary later requires another call.
    CRAFTER_API void EnableWasiBrowserRuntime(Configuration& cfg);

    // Apply the framework's standard CLI args + env vars onto cfg:
    //   --debug             cfg.debug = true
    //   --target=<triple>   cfg.target = <triple>
    //   --march=<value>     cfg.march = <value>
    //   --mtune=<value>     cfg.mtune = <value>
    //   $CRAFTER_BUILD_MARCH / $CRAFTER_BUILD_MTUNE seed march/mtune.
    // Env applies first, then args, so CLI wins over env wins over caller's
    // pre-set defaults. Project-specific flags (e.g. --shared, --timing) are
    // not handled here — parse them in your own loop alongside this call.
    CRAFTER_API void ApplyStandardArgs(Configuration& cfg, std::span<const std::string_view> args);
}