https://github.com/shader-slang/slang
Tip revision: 6f43b2698a99cc4f4bb4e905749fb87f24bf391b authored by jsmall-nvidia on 27 March 2020, 22:35:06 UTC
WaveBroadcastAt/WaveShuffle (#1299)
WaveBroadcastAt/WaveShuffle (#1299)
Tip revision: 6f43b26
slang-type-text-util.cpp
#include "slang-type-text-util.h"
#include "slang-string-util.h"
namespace Slang
{
#define SLANG_SCALAR_TYPES(x) \
x(None, none) \
x(Void, void) \
x(Bool, bool) \
x(Float16, half) \
x(UInt32, uint32_t) \
x(Int32, int32_t) \
x(Int64, int64_t) \
x(UInt64, uint64_t) \
x(Float32, float) \
x(Float64, double)
#define SLANG_PASS_THROUGH_TYPES(x) \
x(none, NONE) \
x(fxc, FXC) \
x(dxc, DXC) \
x(glslang, GLSLANG) \
x(visualstudio, VISUAL_STUDIO) \
x(clang, CLANG) \
x(gcc, GCC) \
x(genericcpp, GENERIC_C_CPP) \
x(nvrtc, NVRTC)
namespace { // anonymous
struct ScalarTypeInfo
{
slang::TypeReflection::ScalarType type;
UnownedStringSlice text;
};
static const ScalarTypeInfo s_scalarTypeInfos[] =
{
#define SLANG_SCALAR_TYPE_INFO(value, text) \
{ slang::TypeReflection::ScalarType::value, UnownedStringSlice::fromLiteral(#text) },
SLANG_SCALAR_TYPES(SLANG_SCALAR_TYPE_INFO)
};
struct CompileTargetInfo
{
SlangCompileTarget target; ///< The target
const char* extensions; ///< Comma delimited list of extensions associated with the target
const char* names; ///< Comma delimited list of names associated with the target. NOTE! First name is taken as the normal display name.
};
static const CompileTargetInfo s_compileTargetInfos[] =
{
{ SLANG_TARGET_UNKNOWN, "", "unknown"},
{ SLANG_TARGET_NONE, "", "none"},
{ SLANG_HLSL, "hlsl,fx", "hlsl"},
{ SLANG_DXBC, "dxbc", "dxbc"},
{ SLANG_DXBC_ASM, "dxbc.asm", "dxbc-asm,dxbc-assembly" },
{ SLANG_DXIL, "dxil", "dxil" },
{ SLANG_DXIL_ASM, "dxil.asm", "dxil-asm,dxil-assembly" },
{ SLANG_GLSL, "glsl,vert,frag,geom,tesc,tese,comp", "glsl" },
{ SLANG_GLSL_VULKAN, "", "glsl-vulkan" },
{ SLANG_GLSL_VULKAN_ONE_DESC, "", "glsl-vulkan-one-desc" },
{ SLANG_SPIRV, "spv", "spirv" },
{ SLANG_SPIRV_ASM, "spv.asm", "spirv-asm,spirv-assembly" },
{ SLANG_C_SOURCE, "c", "c" },
{ SLANG_CPP_SOURCE, "cpp,c++,cxx", "cpp,c++,cxx" },
{ SLANG_EXECUTABLE, "exe", "exe,executable" },
{ SLANG_SHARED_LIBRARY, "dll,so", "sharedlib,sharedlibrary,dll" },
{ SLANG_CUDA_SOURCE, "cu", "cuda,cu" },
{ SLANG_PTX, "ptx", "ptx" },
{ SLANG_HOST_CALLABLE, "", "host-callable,callable" }
};
} // anonymous
/* static */UnownedStringSlice TypeTextUtil::getScalarTypeName(slang::TypeReflection::ScalarType scalarType)
{
typedef slang::TypeReflection::ScalarType ScalarType;
switch (scalarType)
{
#define SLANG_SCALAR_TYPE_TO_TEXT(value, text) case ScalarType::value: return UnownedStringSlice::fromLiteral(#text);
SLANG_SCALAR_TYPES(SLANG_SCALAR_TYPE_TO_TEXT)
default: break;
}
return UnownedStringSlice();
}
/* static */slang::TypeReflection::ScalarType TypeTextUtil::findScalarType(const UnownedStringSlice& inText)
{
for (Index i = 0; i < SLANG_COUNT_OF(s_scalarTypeInfos); ++i)
{
const auto& info = s_scalarTypeInfos[i];
if (info.text == inText)
{
return info.type;
}
}
return slang::TypeReflection::ScalarType::None;
}
/* static */UnownedStringSlice TypeTextUtil::getPassThroughAsHumanText(SlangPassThrough type)
{
switch (type)
{
default:
case SLANG_PASS_THROUGH_NONE: return UnownedStringSlice::fromLiteral("Unknown");
case SLANG_PASS_THROUGH_VISUAL_STUDIO: return UnownedStringSlice::fromLiteral("Visual Studio");
case SLANG_PASS_THROUGH_GCC: return UnownedStringSlice::fromLiteral("GCC");
case SLANG_PASS_THROUGH_CLANG: return UnownedStringSlice::fromLiteral("Clang");
case SLANG_PASS_THROUGH_NVRTC: return UnownedStringSlice::fromLiteral("NVRTC");
case SLANG_PASS_THROUGH_FXC: return UnownedStringSlice::fromLiteral("fxc");
case SLANG_PASS_THROUGH_DXC: return UnownedStringSlice::fromLiteral("dxc");
case SLANG_PASS_THROUGH_GLSLANG: return UnownedStringSlice::fromLiteral("glslang");
}
}
/* static */SlangSourceLanguage TypeTextUtil::findSourceLanguage(const UnownedStringSlice& text)
{
if (text == "c" || text == "C")
{
return SLANG_SOURCE_LANGUAGE_C;
}
else if (text == "cpp" || text == "c++" || text == "C++" || text == "cxx")
{
return SLANG_SOURCE_LANGUAGE_CPP;
}
else if (text == "slang")
{
return SLANG_SOURCE_LANGUAGE_SLANG;
}
else if (text == "glsl")
{
return SLANG_SOURCE_LANGUAGE_GLSL;
}
else if (text == "hlsl")
{
return SLANG_SOURCE_LANGUAGE_HLSL;
}
else if (text == "cu" || text == "cuda")
{
return SLANG_SOURCE_LANGUAGE_CUDA;
}
return SLANG_SOURCE_LANGUAGE_UNKNOWN;
}
/* static */SlangPassThrough TypeTextUtil::findPassThrough(const UnownedStringSlice& slice)
{
#define SLANG_PASS_THROUGH_NAME_TO_TYPE(x, y) \
if (slice == UnownedStringSlice::fromLiteral(#x)) return SLANG_PASS_THROUGH_##y;
SLANG_PASS_THROUGH_TYPES(SLANG_PASS_THROUGH_NAME_TO_TYPE)
// Other options
if (slice == "c" || slice == "cpp")
{
return SLANG_PASS_THROUGH_GENERIC_C_CPP;
}
else if (slice == "vs")
{
return SLANG_PASS_THROUGH_VISUAL_STUDIO;
}
return SLANG_PASS_THROUGH_NONE;
}
/* static */SlangResult TypeTextUtil::findPassThrough(const UnownedStringSlice& slice, SlangPassThrough& outPassThrough)
{
outPassThrough = findPassThrough(slice);
// It could be none on error - if it's not equal to "none" then it must be an error
if (outPassThrough == SLANG_PASS_THROUGH_NONE && slice != UnownedStringSlice::fromLiteral("none"))
{
return SLANG_FAIL;
}
return SLANG_OK;
}
/* static */UnownedStringSlice TypeTextUtil::getPassThroughName(SlangPassThrough passThru)
{
#define SLANG_PASS_THROUGH_TYPE_TO_NAME(x, y) \
case SLANG_PASS_THROUGH_##y: return UnownedStringSlice::fromLiteral(#x);
switch (passThru)
{
SLANG_PASS_THROUGH_TYPES(SLANG_PASS_THROUGH_TYPE_TO_NAME)
default: break;
}
return UnownedStringSlice::fromLiteral("unknown");
}
/* static */SlangCompileTarget TypeTextUtil::findCompileTargetFromExtension(const UnownedStringSlice& slice)
{
if (slice.getLength())
{
for (const auto& info : s_compileTargetInfos)
{
if (StringUtil::indexOfInSplit(UnownedStringSlice(info.extensions), ',', slice) >= 0)
{
return info.target;
}
}
}
return SLANG_TARGET_UNKNOWN;
}
/* static */ SlangCompileTarget TypeTextUtil::findCompileTargetFromName(const UnownedStringSlice& slice)
{
if (slice.getLength())
{
for (const auto& info : s_compileTargetInfos)
{
if (StringUtil::indexOfInSplit(UnownedStringSlice(info.names), ',', slice) >= 0)
{
return info.target;
}
}
}
return SLANG_TARGET_UNKNOWN;
}
static Index _getTargetInfoIndex(SlangCompileTarget target)
{
for (Index i = 0; i < SLANG_COUNT_OF(s_compileTargetInfos); ++i)
{
if (s_compileTargetInfos[i].target == target)
{
return i;
}
}
return -1;
}
UnownedStringSlice TypeTextUtil::getCompileTargetName(SlangCompileTarget target)
{
const Index index = _getTargetInfoIndex(target);
// Return the first name
return index >= 0 ? StringUtil::getAtInSplit(UnownedStringSlice(s_compileTargetInfos[int(target)].names), ',', 0) : UnownedStringSlice();
}
}