1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
#ifndef SLANG_DOWNSTREAM_COMPILER_UTIL_H
#define SLANG_DOWNSTREAM_COMPILER_UTIL_H
#include "slang-downstream-compiler.h"
#include "slang-downstream-compiler-set.h"
namespace Slang
{
typedef SlangResult (*DownstreamCompilerLocatorFunc)(const String& path, ISlangSharedLibraryLoader* loader, DownstreamCompilerSet* set);
struct DownstreamCompilerInfo
{
typedef DownstreamCompilerInfo This;
typedef uint32_t SourceLanguageFlags;
struct SourceLanguageFlag
{
enum Enum : SourceLanguageFlags
{
Unknown = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_UNKNOWN,
Slang = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_SLANG,
HLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_HLSL,
GLSL = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_GLSL,
C = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_C,
CPP = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CPP,
CUDA = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_CUDA,
SPIRV = SourceLanguageFlags(1) << SLANG_SOURCE_LANGUAGE_SPIRV,
};
};
/// Get info for a compiler type
static const This& getInfo(SlangPassThrough compiler);
/// True if this compiler can compile the specified language
static bool canCompile(SlangPassThrough compiler, SlangSourceLanguage sourceLanguage);
DownstreamCompilerInfo() : sourceLanguageFlags(0) {}
DownstreamCompilerInfo(SourceLanguageFlags inSourceLanguageFlags) :
sourceLanguageFlags(inSourceLanguageFlags)
{}
SourceLanguageFlags sourceLanguageFlags;
};
// Combination of a downstream compiler type (pass through) and
// a match version.
struct DownstreamCompilerMatchVersion
{
DownstreamCompilerMatchVersion(SlangPassThrough inType, MatchSemanticVersion inMatchVersion) :
type(inType),
matchVersion(inMatchVersion)
{}
DownstreamCompilerMatchVersion() :type(SLANG_PASS_THROUGH_NONE) {}
SlangPassThrough type; ///< The type of the compiler
MatchSemanticVersion matchVersion; ///< The match version
};
struct DownstreamCompilerUtil: public DownstreamCompilerUtilBase
{
enum class MatchType
{
MinGreaterEqual,
MinAbsolute,
Newest,
};
/// Find a compiler
static IDownstreamCompiler* findCompiler(const DownstreamCompilerSet* set, MatchType matchType, const DownstreamCompilerDesc& desc);
static IDownstreamCompiler* findCompiler(const List<IDownstreamCompiler*>& compilers, MatchType matchType, const DownstreamCompilerDesc& desc);
static IDownstreamCompiler* findCompiler(const List<IDownstreamCompiler*>& compilers, SlangPassThrough type, const SemanticVersion& version);
static IDownstreamCompiler* findCompiler(const List<IDownstreamCompiler*>& compilers, const DownstreamCompilerDesc& desc);
/// Find all the compilers with the version
static void findVersions(const List<IDownstreamCompiler*>& compilers, SlangPassThrough compiler, List<SemanticVersion>& versions);
/// Find the compiler closest to the desc
static IDownstreamCompiler* findClosestCompiler(const List<IDownstreamCompiler*>& compilers, const DownstreamCompilerMatchVersion& version);
static IDownstreamCompiler* findClosestCompiler(const DownstreamCompilerSet* set, const DownstreamCompilerMatchVersion& version);
/// Get the information on the compiler used to compile this source
static DownstreamCompilerMatchVersion getCompiledVersion();
static void updateDefault(DownstreamCompilerSet* set, SlangSourceLanguage sourceLanguage);
static void updateDefaults(DownstreamCompilerSet* set);
static void setDefaultLocators(DownstreamCompilerLocatorFunc outFuncs[int(SLANG_PASS_THROUGH_COUNT_OF)]);
/// Attempts to determine what 'path' is and load appropriately. Is it a path to a shared library? Is it a directory holding the libraries?
/// Some downstream shared libraries need other shared libraries to be loaded before the main shared library, such that they are in the same directory
/// otherwise the shared library could come from some unwanted location.
/// dependentNames names shared libraries which should be attempted to be loaded in the path of the main shared library.
/// The list is optional (nullptr can be passed in), and the list is terminated by nullptr.
static SlangResult loadSharedLibrary(const String& path, ISlangSharedLibraryLoader* loader, const char*const* dependantNames, const char* libraryName, ComPtr<ISlangSharedLibrary>& outSharedLib);
/// Append the desc as text
static void appendAsText(const DownstreamCompilerDesc& desc, StringBuilder& out);
};
}
#endif
|
