904 lines
35 KiB
C++
904 lines
35 KiB
C++
//
|
|
// Copyright (C) 2016 Google, Inc.
|
|
// Copyright (C) 2016 LunarG, Inc.
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of Google, Inc., nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
//
|
|
// HLSL scanning, leveraging the scanning done by the preprocessor.
|
|
//
|
|
|
|
#include <cstring>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
|
|
#include "../glslang/Include/Types.h"
|
|
#include "../glslang/MachineIndependent/SymbolTable.h"
|
|
#include "../glslang/MachineIndependent/ParseHelper.h"
|
|
#include "hlslScanContext.h"
|
|
#include "hlslTokens.h"
|
|
|
|
// preprocessor includes
|
|
#include "../glslang/MachineIndependent/preprocessor/PpContext.h"
|
|
#include "../glslang/MachineIndependent/preprocessor/PpTokens.h"
|
|
|
|
namespace {
|
|
|
|
struct str_eq
|
|
{
|
|
bool operator()(const char* lhs, const char* rhs) const
|
|
{
|
|
return strcmp(lhs, rhs) == 0;
|
|
}
|
|
};
|
|
|
|
struct str_hash
|
|
{
|
|
size_t operator()(const char* str) const
|
|
{
|
|
// djb2
|
|
unsigned long hash = 5381;
|
|
int c;
|
|
|
|
while ((c = *str++) != 0)
|
|
hash = ((hash << 5) + hash) + c;
|
|
|
|
return hash;
|
|
}
|
|
};
|
|
|
|
// A single global usable by all threads, by all versions, by all languages.
|
|
// After a single process-level initialization, this is read only and thread safe
|
|
std::unordered_map<const char*, glslang::EHlslTokenClass, str_hash, str_eq>* KeywordMap = nullptr;
|
|
std::unordered_set<const char*, str_hash, str_eq>* ReservedSet = nullptr;
|
|
std::unordered_map<const char*, glslang::TBuiltInVariable, str_hash, str_eq>* SemanticMap = nullptr;
|
|
|
|
};
|
|
|
|
namespace glslang {
|
|
|
|
void HlslScanContext::fillInKeywordMap()
|
|
{
|
|
if (KeywordMap != nullptr) {
|
|
// this is really an error, as this should called only once per process
|
|
// but, the only risk is if two threads called simultaneously
|
|
return;
|
|
}
|
|
KeywordMap = new std::unordered_map<const char*, EHlslTokenClass, str_hash, str_eq>;
|
|
|
|
(*KeywordMap)["static"] = EHTokStatic;
|
|
(*KeywordMap)["const"] = EHTokConst;
|
|
(*KeywordMap)["unorm"] = EHTokUnorm;
|
|
(*KeywordMap)["snorm"] = EHTokSNorm;
|
|
(*KeywordMap)["extern"] = EHTokExtern;
|
|
(*KeywordMap)["uniform"] = EHTokUniform;
|
|
(*KeywordMap)["volatile"] = EHTokVolatile;
|
|
(*KeywordMap)["precise"] = EHTokPrecise;
|
|
(*KeywordMap)["shared"] = EHTokShared;
|
|
(*KeywordMap)["groupshared"] = EHTokGroupShared;
|
|
(*KeywordMap)["linear"] = EHTokLinear;
|
|
(*KeywordMap)["centroid"] = EHTokCentroid;
|
|
(*KeywordMap)["nointerpolation"] = EHTokNointerpolation;
|
|
(*KeywordMap)["noperspective"] = EHTokNoperspective;
|
|
(*KeywordMap)["sample"] = EHTokSample;
|
|
(*KeywordMap)["row_major"] = EHTokRowMajor;
|
|
(*KeywordMap)["column_major"] = EHTokColumnMajor;
|
|
(*KeywordMap)["packoffset"] = EHTokPackOffset;
|
|
(*KeywordMap)["in"] = EHTokIn;
|
|
(*KeywordMap)["out"] = EHTokOut;
|
|
(*KeywordMap)["inout"] = EHTokInOut;
|
|
(*KeywordMap)["layout"] = EHTokLayout;
|
|
(*KeywordMap)["globallycoherent"] = EHTokGloballyCoherent;
|
|
(*KeywordMap)["inline"] = EHTokInline;
|
|
|
|
(*KeywordMap)["point"] = EHTokPoint;
|
|
(*KeywordMap)["line"] = EHTokLine;
|
|
(*KeywordMap)["triangle"] = EHTokTriangle;
|
|
(*KeywordMap)["lineadj"] = EHTokLineAdj;
|
|
(*KeywordMap)["triangleadj"] = EHTokTriangleAdj;
|
|
|
|
(*KeywordMap)["PointStream"] = EHTokPointStream;
|
|
(*KeywordMap)["LineStream"] = EHTokLineStream;
|
|
(*KeywordMap)["TriangleStream"] = EHTokTriangleStream;
|
|
|
|
(*KeywordMap)["InputPatch"] = EHTokInputPatch;
|
|
(*KeywordMap)["OutputPatch"] = EHTokOutputPatch;
|
|
|
|
(*KeywordMap)["Buffer"] = EHTokBuffer;
|
|
(*KeywordMap)["vector"] = EHTokVector;
|
|
(*KeywordMap)["matrix"] = EHTokMatrix;
|
|
|
|
(*KeywordMap)["void"] = EHTokVoid;
|
|
(*KeywordMap)["string"] = EHTokString;
|
|
(*KeywordMap)["bool"] = EHTokBool;
|
|
(*KeywordMap)["int"] = EHTokInt;
|
|
(*KeywordMap)["uint"] = EHTokUint;
|
|
(*KeywordMap)["uint64_t"] = EHTokUint64;
|
|
(*KeywordMap)["dword"] = EHTokDword;
|
|
(*KeywordMap)["half"] = EHTokHalf;
|
|
(*KeywordMap)["float"] = EHTokFloat;
|
|
(*KeywordMap)["double"] = EHTokDouble;
|
|
(*KeywordMap)["min16float"] = EHTokMin16float;
|
|
(*KeywordMap)["min10float"] = EHTokMin10float;
|
|
(*KeywordMap)["min16int"] = EHTokMin16int;
|
|
(*KeywordMap)["min12int"] = EHTokMin12int;
|
|
(*KeywordMap)["min16uint"] = EHTokMin16uint;
|
|
|
|
(*KeywordMap)["bool1"] = EHTokBool1;
|
|
(*KeywordMap)["bool2"] = EHTokBool2;
|
|
(*KeywordMap)["bool3"] = EHTokBool3;
|
|
(*KeywordMap)["bool4"] = EHTokBool4;
|
|
(*KeywordMap)["float1"] = EHTokFloat1;
|
|
(*KeywordMap)["float2"] = EHTokFloat2;
|
|
(*KeywordMap)["float3"] = EHTokFloat3;
|
|
(*KeywordMap)["float4"] = EHTokFloat4;
|
|
(*KeywordMap)["int1"] = EHTokInt1;
|
|
(*KeywordMap)["int2"] = EHTokInt2;
|
|
(*KeywordMap)["int3"] = EHTokInt3;
|
|
(*KeywordMap)["int4"] = EHTokInt4;
|
|
(*KeywordMap)["double1"] = EHTokDouble1;
|
|
(*KeywordMap)["double2"] = EHTokDouble2;
|
|
(*KeywordMap)["double3"] = EHTokDouble3;
|
|
(*KeywordMap)["double4"] = EHTokDouble4;
|
|
(*KeywordMap)["uint1"] = EHTokUint1;
|
|
(*KeywordMap)["uint2"] = EHTokUint2;
|
|
(*KeywordMap)["uint3"] = EHTokUint3;
|
|
(*KeywordMap)["uint4"] = EHTokUint4;
|
|
|
|
(*KeywordMap)["half1"] = EHTokHalf1;
|
|
(*KeywordMap)["half2"] = EHTokHalf2;
|
|
(*KeywordMap)["half3"] = EHTokHalf3;
|
|
(*KeywordMap)["half4"] = EHTokHalf4;
|
|
(*KeywordMap)["min16float1"] = EHTokMin16float1;
|
|
(*KeywordMap)["min16float2"] = EHTokMin16float2;
|
|
(*KeywordMap)["min16float3"] = EHTokMin16float3;
|
|
(*KeywordMap)["min16float4"] = EHTokMin16float4;
|
|
(*KeywordMap)["min10float1"] = EHTokMin10float1;
|
|
(*KeywordMap)["min10float2"] = EHTokMin10float2;
|
|
(*KeywordMap)["min10float3"] = EHTokMin10float3;
|
|
(*KeywordMap)["min10float4"] = EHTokMin10float4;
|
|
(*KeywordMap)["min16int1"] = EHTokMin16int1;
|
|
(*KeywordMap)["min16int2"] = EHTokMin16int2;
|
|
(*KeywordMap)["min16int3"] = EHTokMin16int3;
|
|
(*KeywordMap)["min16int4"] = EHTokMin16int4;
|
|
(*KeywordMap)["min12int1"] = EHTokMin12int1;
|
|
(*KeywordMap)["min12int2"] = EHTokMin12int2;
|
|
(*KeywordMap)["min12int3"] = EHTokMin12int3;
|
|
(*KeywordMap)["min12int4"] = EHTokMin12int4;
|
|
(*KeywordMap)["min16uint1"] = EHTokMin16uint1;
|
|
(*KeywordMap)["min16uint2"] = EHTokMin16uint2;
|
|
(*KeywordMap)["min16uint3"] = EHTokMin16uint3;
|
|
(*KeywordMap)["min16uint4"] = EHTokMin16uint4;
|
|
|
|
(*KeywordMap)["bool1x1"] = EHTokBool1x1;
|
|
(*KeywordMap)["bool1x2"] = EHTokBool1x2;
|
|
(*KeywordMap)["bool1x3"] = EHTokBool1x3;
|
|
(*KeywordMap)["bool1x4"] = EHTokBool1x4;
|
|
(*KeywordMap)["bool2x1"] = EHTokBool2x1;
|
|
(*KeywordMap)["bool2x2"] = EHTokBool2x2;
|
|
(*KeywordMap)["bool2x3"] = EHTokBool2x3;
|
|
(*KeywordMap)["bool2x4"] = EHTokBool2x4;
|
|
(*KeywordMap)["bool3x1"] = EHTokBool3x1;
|
|
(*KeywordMap)["bool3x2"] = EHTokBool3x2;
|
|
(*KeywordMap)["bool3x3"] = EHTokBool3x3;
|
|
(*KeywordMap)["bool3x4"] = EHTokBool3x4;
|
|
(*KeywordMap)["bool4x1"] = EHTokBool4x1;
|
|
(*KeywordMap)["bool4x2"] = EHTokBool4x2;
|
|
(*KeywordMap)["bool4x3"] = EHTokBool4x3;
|
|
(*KeywordMap)["bool4x4"] = EHTokBool4x4;
|
|
(*KeywordMap)["int1x1"] = EHTokInt1x1;
|
|
(*KeywordMap)["int1x2"] = EHTokInt1x2;
|
|
(*KeywordMap)["int1x3"] = EHTokInt1x3;
|
|
(*KeywordMap)["int1x4"] = EHTokInt1x4;
|
|
(*KeywordMap)["int2x1"] = EHTokInt2x1;
|
|
(*KeywordMap)["int2x2"] = EHTokInt2x2;
|
|
(*KeywordMap)["int2x3"] = EHTokInt2x3;
|
|
(*KeywordMap)["int2x4"] = EHTokInt2x4;
|
|
(*KeywordMap)["int3x1"] = EHTokInt3x1;
|
|
(*KeywordMap)["int3x2"] = EHTokInt3x2;
|
|
(*KeywordMap)["int3x3"] = EHTokInt3x3;
|
|
(*KeywordMap)["int3x4"] = EHTokInt3x4;
|
|
(*KeywordMap)["int4x1"] = EHTokInt4x1;
|
|
(*KeywordMap)["int4x2"] = EHTokInt4x2;
|
|
(*KeywordMap)["int4x3"] = EHTokInt4x3;
|
|
(*KeywordMap)["int4x4"] = EHTokInt4x4;
|
|
(*KeywordMap)["uint1x1"] = EHTokUint1x1;
|
|
(*KeywordMap)["uint1x2"] = EHTokUint1x2;
|
|
(*KeywordMap)["uint1x3"] = EHTokUint1x3;
|
|
(*KeywordMap)["uint1x4"] = EHTokUint1x4;
|
|
(*KeywordMap)["uint2x1"] = EHTokUint2x1;
|
|
(*KeywordMap)["uint2x2"] = EHTokUint2x2;
|
|
(*KeywordMap)["uint2x3"] = EHTokUint2x3;
|
|
(*KeywordMap)["uint2x4"] = EHTokUint2x4;
|
|
(*KeywordMap)["uint3x1"] = EHTokUint3x1;
|
|
(*KeywordMap)["uint3x2"] = EHTokUint3x2;
|
|
(*KeywordMap)["uint3x3"] = EHTokUint3x3;
|
|
(*KeywordMap)["uint3x4"] = EHTokUint3x4;
|
|
(*KeywordMap)["uint4x1"] = EHTokUint4x1;
|
|
(*KeywordMap)["uint4x2"] = EHTokUint4x2;
|
|
(*KeywordMap)["uint4x3"] = EHTokUint4x3;
|
|
(*KeywordMap)["uint4x4"] = EHTokUint4x4;
|
|
(*KeywordMap)["bool1x1"] = EHTokBool1x1;
|
|
(*KeywordMap)["bool1x2"] = EHTokBool1x2;
|
|
(*KeywordMap)["bool1x3"] = EHTokBool1x3;
|
|
(*KeywordMap)["bool1x4"] = EHTokBool1x4;
|
|
(*KeywordMap)["bool2x1"] = EHTokBool2x1;
|
|
(*KeywordMap)["bool2x2"] = EHTokBool2x2;
|
|
(*KeywordMap)["bool2x3"] = EHTokBool2x3;
|
|
(*KeywordMap)["bool2x4"] = EHTokBool2x4;
|
|
(*KeywordMap)["bool3x1"] = EHTokBool3x1;
|
|
(*KeywordMap)["bool3x2"] = EHTokBool3x2;
|
|
(*KeywordMap)["bool3x3"] = EHTokBool3x3;
|
|
(*KeywordMap)["bool3x4"] = EHTokBool3x4;
|
|
(*KeywordMap)["bool4x1"] = EHTokBool4x1;
|
|
(*KeywordMap)["bool4x2"] = EHTokBool4x2;
|
|
(*KeywordMap)["bool4x3"] = EHTokBool4x3;
|
|
(*KeywordMap)["bool4x4"] = EHTokBool4x4;
|
|
(*KeywordMap)["float1x1"] = EHTokFloat1x1;
|
|
(*KeywordMap)["float1x2"] = EHTokFloat1x2;
|
|
(*KeywordMap)["float1x3"] = EHTokFloat1x3;
|
|
(*KeywordMap)["float1x4"] = EHTokFloat1x4;
|
|
(*KeywordMap)["float2x1"] = EHTokFloat2x1;
|
|
(*KeywordMap)["float2x2"] = EHTokFloat2x2;
|
|
(*KeywordMap)["float2x3"] = EHTokFloat2x3;
|
|
(*KeywordMap)["float2x4"] = EHTokFloat2x4;
|
|
(*KeywordMap)["float3x1"] = EHTokFloat3x1;
|
|
(*KeywordMap)["float3x2"] = EHTokFloat3x2;
|
|
(*KeywordMap)["float3x3"] = EHTokFloat3x3;
|
|
(*KeywordMap)["float3x4"] = EHTokFloat3x4;
|
|
(*KeywordMap)["float4x1"] = EHTokFloat4x1;
|
|
(*KeywordMap)["float4x2"] = EHTokFloat4x2;
|
|
(*KeywordMap)["float4x3"] = EHTokFloat4x3;
|
|
(*KeywordMap)["float4x4"] = EHTokFloat4x4;
|
|
(*KeywordMap)["half1x1"] = EHTokHalf1x1;
|
|
(*KeywordMap)["half1x2"] = EHTokHalf1x2;
|
|
(*KeywordMap)["half1x3"] = EHTokHalf1x3;
|
|
(*KeywordMap)["half1x4"] = EHTokHalf1x4;
|
|
(*KeywordMap)["half2x1"] = EHTokHalf2x1;
|
|
(*KeywordMap)["half2x2"] = EHTokHalf2x2;
|
|
(*KeywordMap)["half2x3"] = EHTokHalf2x3;
|
|
(*KeywordMap)["half2x4"] = EHTokHalf2x4;
|
|
(*KeywordMap)["half3x1"] = EHTokHalf3x1;
|
|
(*KeywordMap)["half3x2"] = EHTokHalf3x2;
|
|
(*KeywordMap)["half3x3"] = EHTokHalf3x3;
|
|
(*KeywordMap)["half3x4"] = EHTokHalf3x4;
|
|
(*KeywordMap)["half4x1"] = EHTokHalf4x1;
|
|
(*KeywordMap)["half4x2"] = EHTokHalf4x2;
|
|
(*KeywordMap)["half4x3"] = EHTokHalf4x3;
|
|
(*KeywordMap)["half4x4"] = EHTokHalf4x4;
|
|
(*KeywordMap)["double1x1"] = EHTokDouble1x1;
|
|
(*KeywordMap)["double1x2"] = EHTokDouble1x2;
|
|
(*KeywordMap)["double1x3"] = EHTokDouble1x3;
|
|
(*KeywordMap)["double1x4"] = EHTokDouble1x4;
|
|
(*KeywordMap)["double2x1"] = EHTokDouble2x1;
|
|
(*KeywordMap)["double2x2"] = EHTokDouble2x2;
|
|
(*KeywordMap)["double2x3"] = EHTokDouble2x3;
|
|
(*KeywordMap)["double2x4"] = EHTokDouble2x4;
|
|
(*KeywordMap)["double3x1"] = EHTokDouble3x1;
|
|
(*KeywordMap)["double3x2"] = EHTokDouble3x2;
|
|
(*KeywordMap)["double3x3"] = EHTokDouble3x3;
|
|
(*KeywordMap)["double3x4"] = EHTokDouble3x4;
|
|
(*KeywordMap)["double4x1"] = EHTokDouble4x1;
|
|
(*KeywordMap)["double4x2"] = EHTokDouble4x2;
|
|
(*KeywordMap)["double4x3"] = EHTokDouble4x3;
|
|
(*KeywordMap)["double4x4"] = EHTokDouble4x4;
|
|
|
|
(*KeywordMap)["sampler"] = EHTokSampler;
|
|
(*KeywordMap)["sampler1D"] = EHTokSampler1d;
|
|
(*KeywordMap)["sampler2D"] = EHTokSampler2d;
|
|
(*KeywordMap)["sampler3D"] = EHTokSampler3d;
|
|
(*KeywordMap)["samplerCube"] = EHTokSamplerCube;
|
|
(*KeywordMap)["sampler_state"] = EHTokSamplerState;
|
|
(*KeywordMap)["SamplerState"] = EHTokSamplerState;
|
|
(*KeywordMap)["SamplerComparisonState"] = EHTokSamplerComparisonState;
|
|
(*KeywordMap)["texture"] = EHTokTexture;
|
|
(*KeywordMap)["Texture1D"] = EHTokTexture1d;
|
|
(*KeywordMap)["Texture1DArray"] = EHTokTexture1darray;
|
|
(*KeywordMap)["Texture2D"] = EHTokTexture2d;
|
|
(*KeywordMap)["Texture2DArray"] = EHTokTexture2darray;
|
|
(*KeywordMap)["Texture3D"] = EHTokTexture3d;
|
|
(*KeywordMap)["TextureCube"] = EHTokTextureCube;
|
|
(*KeywordMap)["TextureCubeArray"] = EHTokTextureCubearray;
|
|
(*KeywordMap)["Texture2DMS"] = EHTokTexture2DMS;
|
|
(*KeywordMap)["Texture2DMSArray"] = EHTokTexture2DMSarray;
|
|
(*KeywordMap)["RWTexture1D"] = EHTokRWTexture1d;
|
|
(*KeywordMap)["RWTexture1DArray"] = EHTokRWTexture1darray;
|
|
(*KeywordMap)["RWTexture2D"] = EHTokRWTexture2d;
|
|
(*KeywordMap)["RWTexture2DArray"] = EHTokRWTexture2darray;
|
|
(*KeywordMap)["RWTexture3D"] = EHTokRWTexture3d;
|
|
(*KeywordMap)["RWBuffer"] = EHTokRWBuffer;
|
|
(*KeywordMap)["SubpassInput"] = EHTokSubpassInput;
|
|
(*KeywordMap)["SubpassInputMS"] = EHTokSubpassInputMS;
|
|
|
|
(*KeywordMap)["AppendStructuredBuffer"] = EHTokAppendStructuredBuffer;
|
|
(*KeywordMap)["ByteAddressBuffer"] = EHTokByteAddressBuffer;
|
|
(*KeywordMap)["ConsumeStructuredBuffer"] = EHTokConsumeStructuredBuffer;
|
|
(*KeywordMap)["RWByteAddressBuffer"] = EHTokRWByteAddressBuffer;
|
|
(*KeywordMap)["RWStructuredBuffer"] = EHTokRWStructuredBuffer;
|
|
(*KeywordMap)["StructuredBuffer"] = EHTokStructuredBuffer;
|
|
(*KeywordMap)["TextureBuffer"] = EHTokTextureBuffer;
|
|
|
|
(*KeywordMap)["class"] = EHTokClass;
|
|
(*KeywordMap)["struct"] = EHTokStruct;
|
|
(*KeywordMap)["cbuffer"] = EHTokCBuffer;
|
|
(*KeywordMap)["ConstantBuffer"] = EHTokConstantBuffer;
|
|
(*KeywordMap)["tbuffer"] = EHTokTBuffer;
|
|
(*KeywordMap)["typedef"] = EHTokTypedef;
|
|
(*KeywordMap)["this"] = EHTokThis;
|
|
(*KeywordMap)["namespace"] = EHTokNamespace;
|
|
|
|
(*KeywordMap)["true"] = EHTokBoolConstant;
|
|
(*KeywordMap)["false"] = EHTokBoolConstant;
|
|
|
|
(*KeywordMap)["for"] = EHTokFor;
|
|
(*KeywordMap)["do"] = EHTokDo;
|
|
(*KeywordMap)["while"] = EHTokWhile;
|
|
(*KeywordMap)["break"] = EHTokBreak;
|
|
(*KeywordMap)["continue"] = EHTokContinue;
|
|
(*KeywordMap)["if"] = EHTokIf;
|
|
(*KeywordMap)["else"] = EHTokElse;
|
|
(*KeywordMap)["discard"] = EHTokDiscard;
|
|
(*KeywordMap)["return"] = EHTokReturn;
|
|
(*KeywordMap)["switch"] = EHTokSwitch;
|
|
(*KeywordMap)["case"] = EHTokCase;
|
|
(*KeywordMap)["default"] = EHTokDefault;
|
|
|
|
// TODO: get correct set here
|
|
ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
|
|
|
|
ReservedSet->insert("auto");
|
|
ReservedSet->insert("catch");
|
|
ReservedSet->insert("char");
|
|
ReservedSet->insert("const_cast");
|
|
ReservedSet->insert("enum");
|
|
ReservedSet->insert("explicit");
|
|
ReservedSet->insert("friend");
|
|
ReservedSet->insert("goto");
|
|
ReservedSet->insert("long");
|
|
ReservedSet->insert("mutable");
|
|
ReservedSet->insert("new");
|
|
ReservedSet->insert("operator");
|
|
ReservedSet->insert("private");
|
|
ReservedSet->insert("protected");
|
|
ReservedSet->insert("public");
|
|
ReservedSet->insert("reinterpret_cast");
|
|
ReservedSet->insert("short");
|
|
ReservedSet->insert("signed");
|
|
ReservedSet->insert("sizeof");
|
|
ReservedSet->insert("static_cast");
|
|
ReservedSet->insert("template");
|
|
ReservedSet->insert("throw");
|
|
ReservedSet->insert("try");
|
|
ReservedSet->insert("typename");
|
|
ReservedSet->insert("union");
|
|
ReservedSet->insert("unsigned");
|
|
ReservedSet->insert("using");
|
|
ReservedSet->insert("virtual");
|
|
|
|
SemanticMap = new std::unordered_map<const char*, glslang::TBuiltInVariable, str_hash, str_eq>;
|
|
|
|
// in DX9, all outputs had to have a semantic associated with them, that was either consumed
|
|
// by the system or was a specific register assignment
|
|
// in DX10+, only semantics with the SV_ prefix have any meaning beyond decoration
|
|
// Fxc will only accept DX9 style semantics in compat mode
|
|
// Also, in DX10 if a SV value is present as the input of a stage, but isn't appropriate for that
|
|
// stage, it would just be ignored as it is likely there as part of an output struct from one stage
|
|
// to the next
|
|
bool bParseDX9 = false;
|
|
if (bParseDX9) {
|
|
(*SemanticMap)["PSIZE"] = EbvPointSize;
|
|
(*SemanticMap)["FOG"] = EbvFogFragCoord;
|
|
(*SemanticMap)["DEPTH"] = EbvFragDepth;
|
|
(*SemanticMap)["VFACE"] = EbvFace;
|
|
(*SemanticMap)["VPOS"] = EbvFragCoord;
|
|
}
|
|
|
|
(*SemanticMap)["SV_POSITION"] = EbvPosition;
|
|
(*SemanticMap)["SV_VERTEXID"] = EbvVertexIndex;
|
|
(*SemanticMap)["SV_VIEWPORTARRAYINDEX"] = EbvViewportIndex;
|
|
(*SemanticMap)["SV_TESSFACTOR"] = EbvTessLevelOuter;
|
|
(*SemanticMap)["SV_SAMPLEINDEX"] = EbvSampleId;
|
|
(*SemanticMap)["SV_RENDERTARGETARRAYINDEX"] = EbvLayer;
|
|
(*SemanticMap)["SV_PRIMITIVEID"] = EbvPrimitiveId;
|
|
(*SemanticMap)["SV_OUTPUTCONTROLPOINTID"] = EbvInvocationId;
|
|
(*SemanticMap)["SV_ISFRONTFACE"] = EbvFace;
|
|
(*SemanticMap)["SV_INSTANCEID"] = EbvInstanceIndex;
|
|
(*SemanticMap)["SV_INSIDETESSFACTOR"] = EbvTessLevelInner;
|
|
(*SemanticMap)["SV_GSINSTANCEID"] = EbvInvocationId;
|
|
(*SemanticMap)["SV_DISPATCHTHREADID"] = EbvGlobalInvocationId;
|
|
(*SemanticMap)["SV_GROUPTHREADID"] = EbvLocalInvocationId;
|
|
(*SemanticMap)["SV_GROUPINDEX"] = EbvLocalInvocationIndex;
|
|
(*SemanticMap)["SV_GROUPID"] = EbvWorkGroupId;
|
|
(*SemanticMap)["SV_DOMAINLOCATION"] = EbvTessCoord;
|
|
(*SemanticMap)["SV_DEPTH"] = EbvFragDepth;
|
|
(*SemanticMap)["SV_COVERAGE"] = EbvSampleMask;
|
|
(*SemanticMap)["SV_DEPTHGREATEREQUAL"] = EbvFragDepthGreater;
|
|
(*SemanticMap)["SV_DEPTHLESSEQUAL"] = EbvFragDepthLesser;
|
|
(*SemanticMap)["SV_STENCILREF"] = EbvFragStencilRef;
|
|
}
|
|
|
|
void HlslScanContext::deleteKeywordMap()
|
|
{
|
|
delete KeywordMap;
|
|
KeywordMap = nullptr;
|
|
delete ReservedSet;
|
|
ReservedSet = nullptr;
|
|
delete SemanticMap;
|
|
SemanticMap = nullptr;
|
|
}
|
|
|
|
// Wrapper for tokenizeClass() to get everything inside the token.
|
|
void HlslScanContext::tokenize(HlslToken& token)
|
|
{
|
|
EHlslTokenClass tokenClass = tokenizeClass(token);
|
|
token.tokenClass = tokenClass;
|
|
}
|
|
|
|
glslang::TBuiltInVariable HlslScanContext::mapSemantic(const char* upperCase)
|
|
{
|
|
auto it = SemanticMap->find(upperCase);
|
|
if (it != SemanticMap->end())
|
|
return it->second;
|
|
else
|
|
return glslang::EbvNone;
|
|
}
|
|
|
|
//
|
|
// Fill in token information for the next token, except for the token class.
|
|
// Returns the enum value of the token class of the next token found.
|
|
// Return 0 (EndOfTokens) on end of input.
|
|
//
|
|
EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token)
|
|
{
|
|
do {
|
|
parserToken = &token;
|
|
TPpToken ppToken;
|
|
int token = ppContext.tokenize(ppToken);
|
|
if (token == EndOfInput)
|
|
return EHTokNone;
|
|
|
|
tokenText = ppToken.name;
|
|
loc = ppToken.loc;
|
|
parserToken->loc = loc;
|
|
switch (token) {
|
|
case ';': return EHTokSemicolon;
|
|
case ',': return EHTokComma;
|
|
case ':': return EHTokColon;
|
|
case '=': return EHTokAssign;
|
|
case '(': return EHTokLeftParen;
|
|
case ')': return EHTokRightParen;
|
|
case '.': return EHTokDot;
|
|
case '!': return EHTokBang;
|
|
case '-': return EHTokDash;
|
|
case '~': return EHTokTilde;
|
|
case '+': return EHTokPlus;
|
|
case '*': return EHTokStar;
|
|
case '/': return EHTokSlash;
|
|
case '%': return EHTokPercent;
|
|
case '<': return EHTokLeftAngle;
|
|
case '>': return EHTokRightAngle;
|
|
case '|': return EHTokVerticalBar;
|
|
case '^': return EHTokCaret;
|
|
case '&': return EHTokAmpersand;
|
|
case '?': return EHTokQuestion;
|
|
case '[': return EHTokLeftBracket;
|
|
case ']': return EHTokRightBracket;
|
|
case '{': return EHTokLeftBrace;
|
|
case '}': return EHTokRightBrace;
|
|
case '\\':
|
|
parseContext.error(loc, "illegal use of escape character", "\\", "");
|
|
break;
|
|
|
|
case PPAtomAddAssign: return EHTokAddAssign;
|
|
case PPAtomSubAssign: return EHTokSubAssign;
|
|
case PPAtomMulAssign: return EHTokMulAssign;
|
|
case PPAtomDivAssign: return EHTokDivAssign;
|
|
case PPAtomModAssign: return EHTokModAssign;
|
|
|
|
case PpAtomRight: return EHTokRightOp;
|
|
case PpAtomLeft: return EHTokLeftOp;
|
|
|
|
case PpAtomRightAssign: return EHTokRightAssign;
|
|
case PpAtomLeftAssign: return EHTokLeftAssign;
|
|
case PpAtomAndAssign: return EHTokAndAssign;
|
|
case PpAtomOrAssign: return EHTokOrAssign;
|
|
case PpAtomXorAssign: return EHTokXorAssign;
|
|
|
|
case PpAtomAnd: return EHTokAndOp;
|
|
case PpAtomOr: return EHTokOrOp;
|
|
case PpAtomXor: return EHTokXorOp;
|
|
|
|
case PpAtomEQ: return EHTokEqOp;
|
|
case PpAtomGE: return EHTokGeOp;
|
|
case PpAtomNE: return EHTokNeOp;
|
|
case PpAtomLE: return EHTokLeOp;
|
|
|
|
case PpAtomDecrement: return EHTokDecOp;
|
|
case PpAtomIncrement: return EHTokIncOp;
|
|
|
|
case PpAtomColonColon: return EHTokColonColon;
|
|
|
|
case PpAtomConstInt: parserToken->i = ppToken.ival; return EHTokIntConstant;
|
|
case PpAtomConstUint: parserToken->i = ppToken.ival; return EHTokUintConstant;
|
|
case PpAtomConstFloat16: parserToken->d = ppToken.dval; return EHTokFloat16Constant;
|
|
case PpAtomConstFloat: parserToken->d = ppToken.dval; return EHTokFloatConstant;
|
|
case PpAtomConstDouble: parserToken->d = ppToken.dval; return EHTokDoubleConstant;
|
|
case PpAtomIdentifier:
|
|
{
|
|
EHlslTokenClass token = tokenizeIdentifier();
|
|
return token;
|
|
}
|
|
|
|
case PpAtomConstString: {
|
|
parserToken->string = NewPoolTString(tokenText);
|
|
return EHTokStringConstant;
|
|
}
|
|
|
|
case EndOfInput: return EHTokNone;
|
|
|
|
default:
|
|
if (token < PpAtomMaxSingle) {
|
|
char buf[2];
|
|
buf[0] = (char)token;
|
|
buf[1] = 0;
|
|
parseContext.error(loc, "unexpected token", buf, "");
|
|
} else if (tokenText[0] != 0)
|
|
parseContext.error(loc, "unexpected token", tokenText, "");
|
|
else
|
|
parseContext.error(loc, "unexpected token", "", "");
|
|
break;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
EHlslTokenClass HlslScanContext::tokenizeIdentifier()
|
|
{
|
|
if (ReservedSet->find(tokenText) != ReservedSet->end())
|
|
return reservedWord();
|
|
|
|
auto it = KeywordMap->find(tokenText);
|
|
if (it == KeywordMap->end()) {
|
|
// Should have an identifier of some sort
|
|
return identifierOrType();
|
|
}
|
|
keyword = it->second;
|
|
|
|
switch (keyword) {
|
|
|
|
// qualifiers
|
|
case EHTokStatic:
|
|
case EHTokConst:
|
|
case EHTokSNorm:
|
|
case EHTokUnorm:
|
|
case EHTokExtern:
|
|
case EHTokUniform:
|
|
case EHTokVolatile:
|
|
case EHTokShared:
|
|
case EHTokGroupShared:
|
|
case EHTokLinear:
|
|
case EHTokCentroid:
|
|
case EHTokNointerpolation:
|
|
case EHTokNoperspective:
|
|
case EHTokSample:
|
|
case EHTokRowMajor:
|
|
case EHTokColumnMajor:
|
|
case EHTokPackOffset:
|
|
case EHTokIn:
|
|
case EHTokOut:
|
|
case EHTokInOut:
|
|
case EHTokPrecise:
|
|
case EHTokLayout:
|
|
case EHTokGloballyCoherent:
|
|
case EHTokInline:
|
|
return keyword;
|
|
|
|
// primitive types
|
|
case EHTokPoint:
|
|
case EHTokLine:
|
|
case EHTokTriangle:
|
|
case EHTokLineAdj:
|
|
case EHTokTriangleAdj:
|
|
return keyword;
|
|
|
|
// stream out types
|
|
case EHTokPointStream:
|
|
case EHTokLineStream:
|
|
case EHTokTriangleStream:
|
|
return keyword;
|
|
|
|
// Tessellation patches
|
|
case EHTokInputPatch:
|
|
case EHTokOutputPatch:
|
|
return keyword;
|
|
|
|
case EHTokBuffer:
|
|
case EHTokVector:
|
|
case EHTokMatrix:
|
|
return keyword;
|
|
|
|
// scalar types
|
|
case EHTokVoid:
|
|
case EHTokString:
|
|
case EHTokBool:
|
|
case EHTokInt:
|
|
case EHTokUint:
|
|
case EHTokUint64:
|
|
case EHTokDword:
|
|
case EHTokHalf:
|
|
case EHTokFloat:
|
|
case EHTokDouble:
|
|
case EHTokMin16float:
|
|
case EHTokMin10float:
|
|
case EHTokMin16int:
|
|
case EHTokMin12int:
|
|
case EHTokMin16uint:
|
|
|
|
// vector types
|
|
case EHTokBool1:
|
|
case EHTokBool2:
|
|
case EHTokBool3:
|
|
case EHTokBool4:
|
|
case EHTokFloat1:
|
|
case EHTokFloat2:
|
|
case EHTokFloat3:
|
|
case EHTokFloat4:
|
|
case EHTokInt1:
|
|
case EHTokInt2:
|
|
case EHTokInt3:
|
|
case EHTokInt4:
|
|
case EHTokDouble1:
|
|
case EHTokDouble2:
|
|
case EHTokDouble3:
|
|
case EHTokDouble4:
|
|
case EHTokUint1:
|
|
case EHTokUint2:
|
|
case EHTokUint3:
|
|
case EHTokUint4:
|
|
case EHTokHalf1:
|
|
case EHTokHalf2:
|
|
case EHTokHalf3:
|
|
case EHTokHalf4:
|
|
case EHTokMin16float1:
|
|
case EHTokMin16float2:
|
|
case EHTokMin16float3:
|
|
case EHTokMin16float4:
|
|
case EHTokMin10float1:
|
|
case EHTokMin10float2:
|
|
case EHTokMin10float3:
|
|
case EHTokMin10float4:
|
|
case EHTokMin16int1:
|
|
case EHTokMin16int2:
|
|
case EHTokMin16int3:
|
|
case EHTokMin16int4:
|
|
case EHTokMin12int1:
|
|
case EHTokMin12int2:
|
|
case EHTokMin12int3:
|
|
case EHTokMin12int4:
|
|
case EHTokMin16uint1:
|
|
case EHTokMin16uint2:
|
|
case EHTokMin16uint3:
|
|
case EHTokMin16uint4:
|
|
|
|
// matrix types
|
|
case EHTokBool1x1:
|
|
case EHTokBool1x2:
|
|
case EHTokBool1x3:
|
|
case EHTokBool1x4:
|
|
case EHTokBool2x1:
|
|
case EHTokBool2x2:
|
|
case EHTokBool2x3:
|
|
case EHTokBool2x4:
|
|
case EHTokBool3x1:
|
|
case EHTokBool3x2:
|
|
case EHTokBool3x3:
|
|
case EHTokBool3x4:
|
|
case EHTokBool4x1:
|
|
case EHTokBool4x2:
|
|
case EHTokBool4x3:
|
|
case EHTokBool4x4:
|
|
case EHTokInt1x1:
|
|
case EHTokInt1x2:
|
|
case EHTokInt1x3:
|
|
case EHTokInt1x4:
|
|
case EHTokInt2x1:
|
|
case EHTokInt2x2:
|
|
case EHTokInt2x3:
|
|
case EHTokInt2x4:
|
|
case EHTokInt3x1:
|
|
case EHTokInt3x2:
|
|
case EHTokInt3x3:
|
|
case EHTokInt3x4:
|
|
case EHTokInt4x1:
|
|
case EHTokInt4x2:
|
|
case EHTokInt4x3:
|
|
case EHTokInt4x4:
|
|
case EHTokUint1x1:
|
|
case EHTokUint1x2:
|
|
case EHTokUint1x3:
|
|
case EHTokUint1x4:
|
|
case EHTokUint2x1:
|
|
case EHTokUint2x2:
|
|
case EHTokUint2x3:
|
|
case EHTokUint2x4:
|
|
case EHTokUint3x1:
|
|
case EHTokUint3x2:
|
|
case EHTokUint3x3:
|
|
case EHTokUint3x4:
|
|
case EHTokUint4x1:
|
|
case EHTokUint4x2:
|
|
case EHTokUint4x3:
|
|
case EHTokUint4x4:
|
|
case EHTokFloat1x1:
|
|
case EHTokFloat1x2:
|
|
case EHTokFloat1x3:
|
|
case EHTokFloat1x4:
|
|
case EHTokFloat2x1:
|
|
case EHTokFloat2x2:
|
|
case EHTokFloat2x3:
|
|
case EHTokFloat2x4:
|
|
case EHTokFloat3x1:
|
|
case EHTokFloat3x2:
|
|
case EHTokFloat3x3:
|
|
case EHTokFloat3x4:
|
|
case EHTokFloat4x1:
|
|
case EHTokFloat4x2:
|
|
case EHTokFloat4x3:
|
|
case EHTokFloat4x4:
|
|
case EHTokHalf1x1:
|
|
case EHTokHalf1x2:
|
|
case EHTokHalf1x3:
|
|
case EHTokHalf1x4:
|
|
case EHTokHalf2x1:
|
|
case EHTokHalf2x2:
|
|
case EHTokHalf2x3:
|
|
case EHTokHalf2x4:
|
|
case EHTokHalf3x1:
|
|
case EHTokHalf3x2:
|
|
case EHTokHalf3x3:
|
|
case EHTokHalf3x4:
|
|
case EHTokHalf4x1:
|
|
case EHTokHalf4x2:
|
|
case EHTokHalf4x3:
|
|
case EHTokHalf4x4:
|
|
case EHTokDouble1x1:
|
|
case EHTokDouble1x2:
|
|
case EHTokDouble1x3:
|
|
case EHTokDouble1x4:
|
|
case EHTokDouble2x1:
|
|
case EHTokDouble2x2:
|
|
case EHTokDouble2x3:
|
|
case EHTokDouble2x4:
|
|
case EHTokDouble3x1:
|
|
case EHTokDouble3x2:
|
|
case EHTokDouble3x3:
|
|
case EHTokDouble3x4:
|
|
case EHTokDouble4x1:
|
|
case EHTokDouble4x2:
|
|
case EHTokDouble4x3:
|
|
case EHTokDouble4x4:
|
|
return keyword;
|
|
|
|
// texturing types
|
|
case EHTokSampler:
|
|
case EHTokSampler1d:
|
|
case EHTokSampler2d:
|
|
case EHTokSampler3d:
|
|
case EHTokSamplerCube:
|
|
case EHTokSamplerState:
|
|
case EHTokSamplerComparisonState:
|
|
case EHTokTexture:
|
|
case EHTokTexture1d:
|
|
case EHTokTexture1darray:
|
|
case EHTokTexture2d:
|
|
case EHTokTexture2darray:
|
|
case EHTokTexture3d:
|
|
case EHTokTextureCube:
|
|
case EHTokTextureCubearray:
|
|
case EHTokTexture2DMS:
|
|
case EHTokTexture2DMSarray:
|
|
case EHTokRWTexture1d:
|
|
case EHTokRWTexture1darray:
|
|
case EHTokRWTexture2d:
|
|
case EHTokRWTexture2darray:
|
|
case EHTokRWTexture3d:
|
|
case EHTokRWBuffer:
|
|
case EHTokAppendStructuredBuffer:
|
|
case EHTokByteAddressBuffer:
|
|
case EHTokConsumeStructuredBuffer:
|
|
case EHTokRWByteAddressBuffer:
|
|
case EHTokRWStructuredBuffer:
|
|
case EHTokStructuredBuffer:
|
|
case EHTokTextureBuffer:
|
|
case EHTokSubpassInput:
|
|
case EHTokSubpassInputMS:
|
|
return keyword;
|
|
|
|
// variable, user type, ...
|
|
case EHTokClass:
|
|
case EHTokStruct:
|
|
case EHTokTypedef:
|
|
case EHTokCBuffer:
|
|
case EHTokConstantBuffer:
|
|
case EHTokTBuffer:
|
|
case EHTokThis:
|
|
case EHTokNamespace:
|
|
return keyword;
|
|
|
|
case EHTokBoolConstant:
|
|
if (strcmp("true", tokenText) == 0)
|
|
parserToken->b = true;
|
|
else
|
|
parserToken->b = false;
|
|
return keyword;
|
|
|
|
// control flow
|
|
case EHTokFor:
|
|
case EHTokDo:
|
|
case EHTokWhile:
|
|
case EHTokBreak:
|
|
case EHTokContinue:
|
|
case EHTokIf:
|
|
case EHTokElse:
|
|
case EHTokDiscard:
|
|
case EHTokReturn:
|
|
case EHTokCase:
|
|
case EHTokSwitch:
|
|
case EHTokDefault:
|
|
return keyword;
|
|
|
|
default:
|
|
parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc);
|
|
return EHTokNone;
|
|
}
|
|
}
|
|
|
|
EHlslTokenClass HlslScanContext::identifierOrType()
|
|
{
|
|
parserToken->string = NewPoolTString(tokenText);
|
|
|
|
return EHTokIdentifier;
|
|
}
|
|
|
|
// Give an error for use of a reserved symbol.
|
|
// However, allow built-in declarations to use reserved words, to allow
|
|
// extension support before the extension is enabled.
|
|
EHlslTokenClass HlslScanContext::reservedWord()
|
|
{
|
|
if (! parseContext.symbolTable.atBuiltInLevel())
|
|
parseContext.error(loc, "Reserved word.", tokenText, "", "");
|
|
|
|
return EHTokNone;
|
|
}
|
|
|
|
} // end namespace glslang
|