Build.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Containers/Array.h"
#include "../Containers/VectorSet.h"
#include "../Foundation/Result.h"
#include "../Foundation/TaggedUnion.h"
#include "../Strings/String.h"
#include "Internal/TaggedMap.h"
 
namespace SC
{
namespace Build
{
 
struct Parameters;
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 Compile
{
    enum Type
    {
        includePaths = 0,    
        preprocessorDefines, 
        optimizationLevel,   
        enableASAN,          
        enableRTTI,          
        enableExceptions,    
        enableStdCpp,        
        enableCoverage,      
    };
 
    struct NameDescription
    {
        StringView name;
        StringView description;
    };
 
    static constexpr NameDescription typeToString(Type type)
    {
        switch (type)
        {
        case includePaths: return {"includePaths", "Include paths"};
        case preprocessorDefines: return {"preprocessorDefines", "Preprocessor defines"};
        case optimizationLevel: return {"optimizationLevel", "Optimization level"};
        case enableASAN: return {"enableASAN", "Address Sanitizer"};
        case enableRTTI: return {"enableRTTI", "Runtime Type Identification"};
        case enableExceptions: return {"enableExceptions", "C++ Exceptions"};
        case enableStdCpp: return {"enableStdCpp", "C++ Standard Library"};
        case enableCoverage: return {"enableCoverage", "Code coverage instrumentation"};
        }
        Assert::unreachable();
    }
    template <Type E, typename T>
    using Tag = TaggedType<Type, E, T>; // Helper to save some typing
 
    using FieldsTypes = TypeTraits::TypeList<Tag<includePaths, Vector<String>>,          //
                                             Tag<preprocessorDefines, Vector<String>>,   //
                                             Tag<optimizationLevel, Optimization::Type>, //
                                             Tag<enableASAN, bool>,                      //
                                             Tag<enableRTTI, bool>,                      //
                                             Tag<enableExceptions, bool>,                //
                                             Tag<enableCoverage, bool>,                  //
                                             Tag<enableStdCpp, bool>>;
 
    using Union = TaggedUnion<Compile>;
};
 
struct CompileFlags : public TaggedMap<Compile::Type, Compile::Union>
{
    [[nodiscard]] bool addIncludes(Span<const StringView> includes)
    {
        return getOrCreate<Compile::includePaths>()->append(includes);
    }
 
    [[nodiscard]] bool addDefines(Span<const StringView> defines)
    {
        return getOrCreate<Compile::preprocessorDefines>()->append(defines);
    }
};
 
struct Link
{
    enum Type
    {
        libraryPaths,        
        linkFrameworksAny,   
        linkFrameworksMacOS, 
        linkFrameworksIOS,   
        linkLibraries,       
        guiApplication,      
        enableLTO,           
        enableASAN,          
        enableStdCpp,        
    };
 
    static constexpr StringView typeToString(Type type)
    {
        switch (type)
        {
        case libraryPaths: return "libraryPaths";
        case linkFrameworksAny: return "linkFrameworksAny";
        case linkFrameworksMacOS: return "linkFrameworksMacOS";
        case linkFrameworksIOS: return "linkFrameworksIOS";
        case linkLibraries: return "linkLibraries";
        case guiApplication: return "guiApplication";
        case enableLTO: return "enableLTO";
        case enableASAN: return "enableASAN";
        case enableStdCpp: return "enableStdCpp";
        }
        Assert::unreachable();
    }
    template <Type E, typename T>
    using Tag = TaggedType<Type, E, T>; // Helper to save some typing
 
    using FieldsTypes = TypeTraits::TypeList<Tag<libraryPaths, Vector<String>>,        //
                                             Tag<linkFrameworksAny, Vector<String>>,   //
                                             Tag<linkFrameworksMacOS, Vector<String>>, //
                                             Tag<linkFrameworksIOS, Vector<String>>,   //
                                             Tag<linkLibraries, Vector<String>>,       //
                                             Tag<guiApplication, bool>,                //
                                             Tag<enableLTO, bool>,                     //
                                             Tag<enableASAN, bool>,                    //
                                             Tag<enableStdCpp, bool>                   //
                                             >;
 
    using Union = TaggedUnion<Link>;
};
 
enum class PlatformApple
{
    Any,
    macOS,
    iOS
};
struct LinkFlags : public TaggedMap<Link::Type, Link::Union>
{
    [[nodiscard]] bool addSearchPath(Span<const StringView> libraries)
    {
        return getOrCreate<Link::libraryPaths>()->append(libraries);
    }
 
    [[nodiscard]] bool addFrameworks(Span<const StringView> frameworks, PlatformApple appleOS = PlatformApple::Any)
    {
        switch (appleOS)
        {
        case PlatformApple::macOS: return getOrCreate<Link::linkFrameworksMacOS>()->append(frameworks);
        case PlatformApple::iOS: return getOrCreate<Link::linkFrameworksIOS>()->append(frameworks);
        default: return getOrCreate<Link::linkFrameworksAny>()->append(frameworks);
        }
    }
 
    [[nodiscard]] bool addLibraries(Span<const StringView> libraries)
    {
        return getOrCreate<Link::linkLibraries>()->append(libraries);
    }
};
 
struct Configuration
{
    enum class Preset
    {
        None,          
        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";
        case Configuration::Preset::None: return "None";
        }
        Assert::unreachable();
    }
 
    [[nodiscard]] bool applyPreset(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;    
 
    Preset             preset       = Preset::None;      
    Architecture::Type architecture = Architecture::Any; 
 
    Configuration();
};
 
struct TargetType
{
    enum Type
    {
        Executable,     
        DynamicLibrary, 
        StaticLibrary   
    };
 
    static constexpr StringView typeToString(Type type)
    {
        switch (type)
        {
        case Executable: return "Executable";
        case DynamicLibrary: return "DynamicLibrary";
        case StaticLibrary: return "StaticLibrary";
        }
        Assert::unreachable();
    }
};
 
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::Executable; 
 
    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; 
    CompileFlags    compile;  
    LinkFlags       link;     
 
    [[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;
};
 
struct DefinitionCompiler
{
    VectorMap<String, Vector<String>> resolvedPaths;
 
    const Build::Definition& definition;
    DefinitionCompiler(const Build::Definition& definition) : definition(definition) {}
 
    [[nodiscard]] Result validate();
    [[nodiscard]] Result build();
 
  private:
    [[nodiscard]] static Result fillPathsList(StringView path, const VectorSet<Project::File>& filters,
                                              VectorMap<String, Vector<String>>& filtersToFiles);
    [[nodiscard]] Result        collectUniqueRootPaths(VectorMap<String, VectorSet<Project::File>>& paths);
};
 
//-----------------------------------------------------------------------------------------------------------------------
// 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