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 Warning
{
    enum State
    {
        Disabled // TODO: Add enabled state
    };
 
    enum Type
    {
        MSVCWarning,
        NotMSVCWarning,
        ClangWarning,
        GCCWarning,
    };
 
    State      state = Disabled;
    Type       type  = MSVCWarning;
    StringView name;
    uint32_t   number = 0;
 
    Warning(State state, StringView name, Type type = NotMSVCWarning) : state(state), type(type), name(name) {}
    Warning(State state, uint32_t number) : state(state), type(MSVCWarning), number(number) {}
};
 
struct CompileFlags
{
    Vector<String>  includePaths; 
    Vector<String>  defines;      
    Vector<Warning> warnings;     
 
    Parameter<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; 
 
    static Result merge(Span<const CompileFlags*> opinions, CompileFlags& flags);
 
    [[nodiscard]] bool disableWarnings(Span<const uint32_t> number);
 
    [[nodiscard]] bool disableWarnings(Span<const StringView> name);
 
    [[nodiscard]] bool disableClangWarnings(Span<const StringView> name);
 
    [[nodiscard]] bool disableGCCWarnings(Span<const StringView> name);
 
    [[nodiscard]] bool addIncludePaths(Span<const StringView> includePaths);
 
    [[nodiscard]] bool addDefines(Span<const StringView> defines);
 
  private:
    friend struct LinkFlags;
    struct Internal;
};
 
struct LinkFlags
{
    Vector<String> libraryPaths;    
    Vector<String> libraries;       
    Vector<String> frameworks;      
    Vector<String> frameworksIOS;   
    Vector<String> frameworksMacOS; 
 
    Parameter<bool> enableASAN = false; 
 
    static Result merge(Span<const LinkFlags*> opinions, LinkFlags& flags);
};
 
struct FilesSelection
{
    enum Action
    {
        Add,   
        Remove 
    };
    Action action = Add; 
    String base;         
    String mask;         
 
    bool operator==(const FilesSelection& other) const
    {
        // collectUniqueRootPaths doesn't care about de-duplicating also operation
        return base == other.base and mask == other.mask;
    }
};
 
struct SourceFiles
{
    Vector<FilesSelection> selection;
    CompileFlags           compile;
 
    [[nodiscard]] bool addSelection(StringView directory, StringView filter);
 
    [[nodiscard]] bool removeSelection(StringView directory, StringView filter);
};
 
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
{
    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;      
 
    SourceFiles files; 
    LinkFlags   link;  
 
    Vector<SourceFiles> filesWithSpecificFlags; 
 
    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 addFiles(StringView subdirectory, StringView filter);
 
    [[nodiscard]] bool addFile(StringView singleFile);
 
    [[nodiscard]] bool addSpecificFileFlags(SourceFiles selection);
 
    [[nodiscard]] bool addIncludePaths(Span<const StringView> includePaths);
 
    [[nodiscard]] bool addLinkLibraryPaths(Span<const StringView> libraryPaths);
 
    [[nodiscard]] bool addLinkLibraries(Span<const StringView> linkLibraries);
 
    [[nodiscard]] bool addLinkFrameworks(Span<const StringView> frameworks);
 
    [[nodiscard]] bool addLinkFrameworksMacOS(Span<const StringView> frameworks);
 
    [[nodiscard]] bool addLinkFrameworksIOS(Span<const StringView> frameworks);
 
    [[nodiscard]] bool addDefines(Span<const StringView> defines);
 
    [[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