CompilerTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "uLang/Semantics/SemanticProgram.h"
#include "uLang/Diagnostics/Diagnostics.h"
#include "uLang/CompilerPasses/ApiLayerInjections.h"
 
namespace uLang
{
 
// Forward declarations
enum class EAstNodeSetKey : uintptr_t;
 
struct SToolchainInjections
{
    TSRefArray<IPreParseInjection>         _PreParseInjections;
    TSRefArray<IPostParseInjection>        _PostParseInjections;
    TSRefArray<IPreSemAnalysisInjection>   _PreSemAnalysisInjections;
    TSRefArray<IIntraSemAnalysisInjection> _IntraSemAnalysisInjections;
    TSRefArray<IPostSemAnalysisInjection>  _PostSemAnalysisInjections;
    TSRefArray<IPreTranslateInjection>     _PreTranslateInjections;
    TSRefArray<IPreLinkInjection>          _PreLinkInjections;
};
 
struct FSolFingerprint
{
    alignas(uint32_t) uint8_t Bytes[20]{};
    static const FSolFingerprint Zero;
 
    void Reset()
    {
        memset(Bytes, 0, sizeof(Bytes));
    }
 
    friend inline bool operator==(const FSolFingerprint& A, const FSolFingerprint& B)
    {
        return memcmp(A.Bytes, B.Bytes, sizeof(A.Bytes)) == 0;
    }
 
    friend inline bool operator!=(const FSolFingerprint& A, const FSolFingerprint& B)
    {
        return memcmp(A.Bytes, B.Bytes, sizeof(A.Bytes)) != 0;
    }
 
    CUTF8String ToCUTF8String() const
    {
        const auto NibbleToHex = [](uint8_t Value) { return char(Value + (Value > 9 ? 'A' - 10 : '0')); };
 
        CUTF8String Output;
        const uint64_t CharLength = sizeof(Bytes) * 2;
        Output.Resize(CharLength + 1);
 
        const uint8_t* Data = Bytes;
        char* WriteHead = (char*) Output.begin().CurrentByte();
        for (const uint8_t* DataEnd = Data + sizeof(Bytes); Data != DataEnd; ++Data)
        {
            *WriteHead++ = NibbleToHex(*Data >> 4);
            *WriteHead++ = NibbleToHex(*Data & 15);
        }
        *WriteHead++ = 0;
        return Output;
    }
};
inline const FSolFingerprint FSolFingerprint::Zero;
 
struct FSolFingerprintDiagnostics : public CSharedMix
{
    TArray<CUTF8String> _Updates;
};
 
class ISolFingerprintGenerator : public CSharedMix
{
public:
    virtual ~ISolFingerprintGenerator() {}
 
    virtual void Reset() = 0;
    virtual void Update(const void* Data, uint64_t Size, const char* DebugContext = nullptr) = 0;
    virtual FSolFingerprint Finalize(const char* DebugContext = nullptr) = 0;
};
 
struct SCommandLine
{
    TArray<CUTF8String> _Tokens;
    TArray<CUTF8String> _Switches;
    CUTF8String _Unparsed;
};
 
struct SPackageUsageEntry
{
    CUTF8String _PackageName;
    TArray<CUTF8String> _UsedDependencies; // Only _directly_ used dependencies, not transitive closure
};
 
struct SPackageUsage
{
    TArray<SPackageUsageEntry> _Packages;
};
 
struct SBuildParams
{
    uint32_t _UploadedAtFNVersion = VerseFN::UploadedAtFNVersion::Latest;
 
    int32_t _MaxNumPersistentVars = 0;
 
    enum class ELinkParam
    {
        RequireComplete, // Require complete link
        Skip,            // Skip link step
        Default,
    };
 
    ELinkParam _LinkType = ELinkParam::Default;
 
    // HACK_VMSWITCH - remove this once VerseVM is fully brought up
    // Specifies the VM we are compiling the code for
    // We need a variable for this, since even though in most cases
    // WITH_VERSE_BPVM will select the correct value, in the VNI tool we
    // take this information from the command line
    enum class EWhichVM
    {
        VerseVM,
        BPVM
    };
#if WITH_VERSE_BPVM
    EWhichVM _TargetVM = EWhichVM::BPVM;
#else
    EWhichVM _TargetVM = EWhichVM::VerseVM;
#endif
 
    bool _bSemanticAnalysisOnly : 1 = false;
 
    bool _bGenerateDigests : 1 = true;
 
    bool _bGenerateCode : 1 = true;
 
    bool _bQualifyIdentifiers : 1 = false;
 
    bool _bVerbose : 1 = false;
};
 
struct SBuildContext
{
    TSRef<CDiagnostics> _Diagnostics;
    SToolchainInjections _AddedInjections;
    TArray<CUTF8String> _BuiltInPackageNames = {"Solaris/VerseNative"}; // HACK for now, at least just in one place :-)
    TUPtr<SPackageUsage> _PackageUsage;
    SBuildParams _Params;
 
    bool bCloneValidSnippetVsts = false;
 
    explicit SBuildContext(TSRef<CDiagnostics> Diagnostics) : _Diagnostics(Move(Diagnostics)) {}
 
    SBuildContext()
        : _Diagnostics(TSRef<CDiagnostics>::New())
    {}
};
 
struct SProgramContext
{
    TSRef<CSemanticProgram> _Program;
 
    SProgramContext(const TSRef<CSemanticProgram>& Program)
        : _Program(Program)
    {}
};
 
} // namespace uLang