Toolchain.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "uLang/Common/Containers/SharedPointerArray.h"
#include "uLang/Common/Misc/Optional.h"
#include "uLang/Common/Misc/EnumUtils.h" // for ULANG_ENUM_BIT_FLAGS()
#include "uLang/CompilerPasses/IParserPass.h"
#include "uLang/CompilerPasses/IPostVstFilter.h"
#include "uLang/CompilerPasses/ISemanticAnalyzerPass.h"
#include "uLang/CompilerPasses/IPostSemanticAnalysisFilter.h"
#include "uLang/CompilerPasses/IPostIrFilter.h"
#include "uLang/CompilerPasses/IIRGeneratorPass.h"
#include "uLang/CompilerPasses/IAssemblerPass.h"
#include "uLang/CompilerPasses/ApiLayerInjections.h"
#include "uLang/Semantics/SemanticProgram.h"
#include "uLang/Syntax/VstNode.h" // for Vst::Node
#include "uLang/SourceProject/SourceProject.h"
#include "uLang/SourceProject/VerseVersion.h"
#include "uLang/VerseLocalizationGen.h"
 
#define UE_API VERSECOMPILER_API
 
namespace uLang
{
 
    // Forward declarations
    class  CToolchain;
    class  CUTF8StringView;
 
    struct SToolchainParams
    {
        TOptional<TSRef<IParserPass>>           Parser;
 
        TSRefArray<IPostVstFilter>              PostVstFilters;
 
        TOptional<TSRef<ISemanticAnalyzerPass>> SemanticAnalyzer;
 
        TSRefArray<IPostSemanticAnalysisFilter>  PostSemanticAnalysisFilters;
        
        TSRefArray<IPostIrFilter>                PostIrFilters;
 
        TOptional<TSRef<IIrGeneratorPass>>       IrGenerator;
 
        TOptional<TSRef<IAssemblerPass>>        Assembler;
 
        SToolchainInjections                    LayerInjections;
    };
 
    VERSECOMPILER_API TSRef<CToolchain> CreateToolchain(const SToolchainParams& Params);
 
    enum class ECompilerResult : uint32_t
    {
        Compile_NoOp                = (0x00),
 
        Compile_RanSyntaxPass       = (1<<0),
        Compile_RanSemanticPass     = (1<<1),
        Compile_RanLocalizationPass = (1<<2),
        Compile_RanIrPass           = (1<<3),
        Compile_RanCodeGenPass      = (1<<4),
 
        Compile_SkippedByInjection  = (1<<5),
        Compile_SkippedByEmptyPass  = (1<<6),
 
        Compile_SyntaxError         = (1<<7),
        Compile_SemanticError       = (1<<8),
        Compile_IrError             = (1<<9),
        Compile_LocalizationError   = (1<<10),
        Compile_CodeGenError        = (1<<11),
 
        CompileMask_Failure = (Compile_SyntaxError | Compile_SemanticError | Compile_IrError | Compile_LocalizationError | Compile_CodeGenError),
        CompileMask_Skipped = (Compile_SkippedByInjection | Compile_SkippedByEmptyPass),
        CompileMask_Aborted = (CompileMask_Failure | CompileMask_Skipped),
    };
    ULANG_ENUM_BIT_FLAGS(ECompilerResult, inline);
 
    ULANG_FORCEINLINE bool IsCompileFailure(ECompilerResult E)    { return Enum_HasAnyFlags(E, ECompilerResult::CompileMask_Failure); }
    ULANG_FORCEINLINE bool IsAbortedCompile(ECompilerResult E)    { return Enum_HasAnyFlags(E, ECompilerResult::CompileMask_Aborted); }
    ULANG_FORCEINLINE bool IsCompileIncomplete(ECompilerResult E) { return !E || IsAbortedCompile(E); }
    ULANG_FORCEINLINE bool IsCompileComplete(ECompilerResult E)   { return !IsCompileIncomplete(E); }
 
    struct SBuildResults
    {
        VERSECOMPILER_API bool HasFailure() const;
        SBuildResults& operator |= (const SBuildResults& Other);
 
        SBuildStatistics _Statistics = {};
 
        bool            _IOErrorsFound  = false;
        ECompilerResult _CompilerResult = ECompilerResult::Compile_NoOp;
        ELinkerResult   _LinkerResult   = ELinkerResult::Link_Skipped;
    };
 
    /* Compiler+Linker toolchain
     **************************************************************************/
 
    class CToolchain : public CSharedMix
    {
    public:
        UE_API SBuildResults BuildProject(const CSourceProject& SourceProject, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ECompilerResult ParseSnippet(const uLang::TSRef<Verse::Vst::Snippet>& OutVst,
                                     const CUTF8StringView& TextSnippet,
                                     const SBuildContext& BuildContext,
                                     const uint32_t VerseVersion = Verse::Version::Default,
                                     const uint32_t UploadedAtFNVersion = VerseFN::UploadedAtFNVersion::Latest);
 
        UE_API ECompilerResult CompileVst(const TSRef<Verse::Vst::Project>& Vst, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ECompilerResult SemanticAnalyzeVst(TOptional<TSRef<CSemanticProgram>>& OutProgram, const TSRef<Verse::Vst::Project>& Vst, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ECompilerResult ExtractLocalization(const TSRef<CSemanticProgram>& Program, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ECompilerResult IrGenerateProgram(const TSRef<CSemanticProgram>& Program, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ECompilerResult AssembleProgram(const TSRef<CSemanticProgram>& Program, const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        UE_API ELinkerResult Link(const SBuildContext& BuildContext, const SProgramContext& ProgramContext);
 
        const TOptional<TSRef<IParserPass>>&            GetParser() const { return _Params.Parser; }
        const TSRefArray<IPostVstFilter>&               GetPostVstFilters() const { return _Params.PostVstFilters; }
        const TOptional<TSRef<ISemanticAnalyzerPass>>&  GetSemanticAnalyzer() const { return _Params.SemanticAnalyzer; }
        const TSRefArray<IPostSemanticAnalysisFilter>&  GetPostSemanticAnalysisFilters() const { return _Params.PostSemanticAnalysisFilters; }
        const TSRefArray<IPostIrFilter>&                GetPostIrFilters() const { return _Params.PostIrFilters; }
        const TOptional<TSRef<IAssemblerPass>>&         GetAssembler() const { return _Params.Assembler; }
        const TSPtr<Verse::Vst::Project>&               GetProjectVst() const { return _ProjectVst; }
 
        void SetProjectVst(const TSRef<Verse::Vst::Project>& NewProject)
        {
            this->_ProjectVst = NewProject;
        }
 
        // Take localization information, i.e, it removes it from this object.
        UE_API TArray<FSolLocalizationInfo> TakeLocalizationInfo();
 
        // Take string information, i.e, it removes it from this object.
        UE_API TArray<FSolLocalizationInfo> TakeStringInfo();
 
    private:
        friend VERSECOMPILER_API TSRef<CToolchain> CreateToolchain(const SToolchainParams& Params);
        friend TSRef<CToolchain>;
        UE_API CToolchain(const SToolchainParams& Params); // use CreateToolchain() to construct
 
        struct SOrderedPackage
        {
            const CSourcePackage* _Package = nullptr;
            int32_t _DependencyDepth = -1;
        };
 
        // Build a list of packages ordered by dependency depth
        // Returns true if successful, or false if glitches were encountered
        UE_API bool BuildOrderedPackageList(const CSourceProject& SourceProject, const SBuildContext& BuildContext, TArray<SOrderedPackage>& OutOrderedPackageList) const;
 
        SToolchainParams _Params;
 
        TSPtr<Verse::Vst::Project> _ProjectVst; 
 
        // Localization and string information stored here.
        TArray<FSolLocalizationInfo> _LocalizationInfo;
        TArray<FSolLocalizationInfo> _StringInfo;
    };
}
 
#undef UE_API