Build.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Containers/Vector.h"
#include "../Foundation/Result.h"
#include "../Strings/String.h"
 
namespace SC
{
namespace Build
{
 
struct Parameters;
struct Project;
 
template <typename T>
struct Parameter
{
    Parameter() = default;
    Parameter(const T& other) : value(other) {}
    operator const T&() const { return value; }
 
    bool hasBeenSet() const { return valueSet; }
    void unset() { valueSet = false; }
 
    Parameter& operator=(const T& other)
    {
        value    = other;
        valueSet = true;
        return *this;
    }
 
  private:
    T    value;
    bool valueSet = false;
};
 
struct Platform
{
    enum Type
    {
        Unknown = 0,
        Windows,
        Apple,
        Linux,
        Wasm
    };
 
    static constexpr StringView toString(Type type)
    {
        switch (type)
        {
        case Unknown: return "unknown";
        case Windows: return "windows";
        case Apple: return "apple";
        case Linux: return "linux";
        case Wasm: return "wasm";
        }
        Assert::unreachable();
    }
};
 
struct Architecture
{
    enum Type
    {
        Any = 0,
        Intel32,
        Intel64,
        Arm64,
        Wasm
    };
 
    static constexpr StringView toString(Type type)
    {
        switch (type)
        {
        case Any: return "Any";
        case Intel32: return "Intel32";
        case Intel64: return "Intel64";
        case Arm64: return "Arm64";
        case Wasm: return "Wasm";
        }
        Assert::unreachable();
    }
};
 
struct Generator
{
    enum Type
    {
        XCode,            
        VisualStudio2022, 
        VisualStudio2019, 
        Make,             
    };
 
    static constexpr StringView toString(Type type)
    {
        switch (type)
        {
        case XCode: return "XCode";
        case VisualStudio2022: return "VisualStudio2022";
        case VisualStudio2019: return "VisualStudio2019";
        case Make: return "Make";
        }
        Assert::unreachable();
    }
};
 
struct Optimization
{
    enum Type
    {
        Debug,   
        Release, 
    };
 
    static constexpr StringView toString(Type type)
    {
        switch (type)
        {
        case Debug: return "Debug"_a8;
        case Release: return "Release"_a8;
        }
        Assert::unreachable();
    }
};
 
struct CompileFlags
{
    Vector<String> includePaths; 
    Vector<String> defines;      
 
    Optimization::Type optimizationLevel = Optimization::Release; 
 
    Parameter<bool> enableASAN       = false; 
    Parameter<bool> enableRTTI       = false; 
    Parameter<bool> enableExceptions = false; 
    Parameter<bool> enableStdCpp     = false; 
    Parameter<bool> enableCoverage   = false; 
};
 
struct LinkFlags
{
    Vector<String> libraryPaths;    
    Vector<String> libraries;       
    Vector<String> frameworks;      
    Vector<String> frameworksIOS;   
    Vector<String> frameworksMacOS; 
 
    Parameter<bool> enableASAN   = false; 
    Parameter<bool> enableStdCpp = false; 
};
 
struct Configuration
{
    enum class Preset
    {
        Debug,         
        DebugCoverage, 
        Release,       
    };
 
    struct VisualStudio
    {
        StringView platformToolset;
    };
 
    VisualStudio visualStudio; 
 
    [[nodiscard]] static constexpr StringView PresetToString(Preset preset)
    {
        switch (preset)
        {
        case Configuration::Preset::Debug: return "Debug";
        case Configuration::Preset::DebugCoverage: return "DebugCoverage";
        case Configuration::Preset::Release: return "Release";
        }
        Assert::unreachable();
    }
 
    [[nodiscard]] bool applyPreset(const Project& project, Preset newPreset, const Parameters& parameters);
 
    [[nodiscard]] static constexpr StringView getStandardBuildDirectory()
    {
        return "$(TARGET_OS)-$(TARGET_ARCHITECTURES)-$(BUILD_SYSTEM)-$(COMPILER)-$(CONFIGURATION)";
    }
 
    String name;              
    String outputPath;        
    String intermediatesPath; 
 
    CompileFlags compile; 
    LinkFlags    link;    
 
    Architecture::Type architecture = Architecture::Any; 
 
    Configuration();
};
 
struct TargetType
{
    enum Type
    {
        ConsoleExecutable, 
        GUIApplication,    
    };
};
 
struct Project
{
    struct File
    {
        enum Operation
        {
            Add,   
            Remove 
        };
        Operation operation = Add; 
        String    base;            
        String    mask;            
 
        bool operator==(const File& other) const
        {
            // collectUniqueRootPaths doesn't care about de-duplicating also operation
            return base == other.base and mask == other.mask;
        }
    };
 
    Project() = default;
    Project(TargetType::Type targetType, StringView name) : targetType(targetType), name(name), targetName(name) {}
 
    TargetType::Type targetType = TargetType::ConsoleExecutable; 
 
    String name;          
    String rootDirectory; 
    String targetName;    
    String iconPath;      
 
    Vector<File> files;   
    CompileFlags compile; 
    LinkFlags    link;    
 
    Vector<Configuration> configurations; 
 
    [[nodiscard]] bool setRootDirectory(StringView file);
 
    [[nodiscard]] bool addPresetConfiguration(Configuration::Preset preset, const Parameters& parameters,
                                              StringView configurationName = StringView());
 
    [[nodiscard]] Configuration* getConfiguration(StringView configurationName);
    [[nodiscard]] const Configuration* getConfiguration(StringView configurationName) const;
 
    [[nodiscard]] bool addDirectory(StringView subdirectory, StringView filter);
 
    [[nodiscard]] bool addFile(StringView singleFile);
 
    [[nodiscard]] bool removeFiles(StringView subdirectory, StringView filter);
 
    [[nodiscard]] Result validate() const;
};
 
struct Workspace
{
    Workspace() = default;
    Workspace(StringView name) : name(name) {}
 
    String          name;     
    Vector<Project> projects; 
 
    [[nodiscard]] Result validate() const;
};
 
struct Directories
{
    String projectsDirectory;
    String intermediatesDirectory;
    String outputsDirectory;
    String packagesCacheDirectory;
    String packagesInstallDirectory;
    String libraryDirectory;
};
 
struct Parameters
{
    Platform::Type     platform;     
    Architecture::Type architecture; 
    Generator::Type    generator;    
 
    Parameters()
    {
        platform     = Platform::Linux;
        architecture = Architecture::Any;
        generator    = Generator::Make;
    }
    Directories directories;
};
 
struct Definition
{
    Vector<Workspace> workspaces; 
 
    Result configure(StringView projectName, const Parameters& parameters) const;
};
 
 
//-----------------------------------------------------------------------------------------------------------------------
// Implementations Details
//-----------------------------------------------------------------------------------------------------------------------
 
struct Action
{
    enum Type
    {
        Configure,
        Compile,
        Run,
        Print,
        Coverage
    };
    using ConfigureFunction = Result (*)(Build::Definition& definition, const Build::Parameters& parameters);
 
    static Result execute(const Action& action, ConfigureFunction configure, StringView projectName);
 
    Type action = Configure;
 
    Parameters parameters;
    StringView configuration;
    StringView target;
 
  private:
    struct Internal;
};
 
// Defined inside SC-Build.cpp
Result executeAction(const Action& action);
} // namespace Build
} // namespace SC