diff --git a/deps/glslang/glslang.diff b/deps/glslang/glslang.diff new file mode 100644 index 0000000000..7eaec733f9 --- /dev/null +++ b/deps/glslang/glslang.diff @@ -0,0 +1,4179 @@ +diff --git a/deps/glslang/glslang/SPIRV/doc.h b/deps/glslang/glslang/SPIRV/doc.h +index 7d0475d3eb..eb6b4b963e 100644 +--- a/deps/glslang/glslang/SPIRV/doc.h ++++ b/deps/glslang/glslang/SPIRV/doc.h +@@ -32,6 +32,9 @@ + // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + // POSSIBILITY OF SUCH DAMAGE. + ++#ifndef _SPIRV_doc_h ++#define _SPIRV_doc_h ++ + // + // Parameterize the SPIR-V enumerants. + // +@@ -256,3 +259,5 @@ const char* AccessQualifierString(int attr); + void PrintOperands(const OperandParameters& operands, int reservedOperands); + + }; // end namespace spv ++ ++#endif +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h b/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h +index 7333bc964e..fcb1fa9bb7 100644 +--- a/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h ++++ b/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h +@@ -33,6 +33,9 @@ + // POSSIBILITY OF SUCH DAMAGE. + // + ++#ifndef _MACHINE_INDEPENDENT_LIVE_TRAVERSER_H ++#define _MACHINE_INDEPENDENT_LIVE_TRAVERSER_H ++ + #pragma once + + #include "../Include/Common.h" +@@ -136,3 +139,5 @@ private: + }; + + } // namespace glslang ++ ++#endif +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp b/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp +index aa21d8a11e..0464f965fd 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp +@@ -54,6 +54,7 @@ + // preprocessor includes + #include "preprocessor/PpContext.h" + #include "preprocessor/PpTokens.h" ++#include "preprocessor/Compare.h" + + // Required to avoid missing prototype warnings for some compilers + int yylex(YYSTYPE*, glslang::TParseContext&); +@@ -289,38 +290,15 @@ protected: + } // end namespace glslang + + // This is the function the glslang parser (i.e., bison) calls to get its next token +-int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& parseContext) ++int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& _parseContext) + { + glslang::TParserToken token(*glslangTokenDesc); + +- return parseContext.getScanContext()->tokenize(parseContext.getPpContext(), token); ++ return _parseContext.getScanContext()->tokenize(_parseContext.getPpContext(), token); + } + + 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* KeywordMap = nullptr; +@@ -781,7 +759,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) + case '{': afterStruct = false; return LEFT_BRACE; + case '}': return RIGHT_BRACE; + case '\\': +- parseContext.error(loc, "illegal use of escape character", "\\", ""); ++ _parseContext.error(loc, "illegal use of escape character", "\\", ""); + break; + + case PPAtomAddAssign: return ADD_ASSIGN; +@@ -812,7 +790,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) + case PpAtomIncrement: return INC_OP; + + case PpAtomColonColon: +- parseContext.error(loc, "not supported", "::", ""); ++ _parseContext.error(loc, "not supported", "::", ""); + break; + + case PpAtomConstInt: parserToken->sType.lex.i = ppToken.ival; return INTCONSTANT; +@@ -837,7 +815,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) + char buf[2]; + buf[0] = (char)token; + buf[1] = 0; +- parseContext.error(loc, "unexpected token", buf, ""); ++ _parseContext.error(loc, "unexpected token", buf, ""); + break; + } + } while (true); +@@ -878,15 +856,15 @@ int TScanContext::tokenizeIdentifier() + return keyword; + + case NONUNIFORM: +- if (parseContext.extensionTurnedOn(E_GL_EXT_nonuniform_qualifier)) ++ if (_parseContext.extensionTurnedOn(E_GL_EXT_nonuniform_qualifier)) + return keyword; + else + return identifierOrType(); + + case SWITCH: + case DEFAULT: +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 130)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 130)) + reservedWord(); + return keyword; + +@@ -920,19 +898,19 @@ int TScanContext::tokenizeIdentifier() + + case ATTRIBUTE: + case VARYING: +- if (parseContext.profile == EEsProfile && parseContext.version >= 300) ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) + reservedWord(); + return keyword; + + case BUFFER: +- if ((parseContext.profile == EEsProfile && parseContext.version < 310) || +- (parseContext.profile != EEsProfile && parseContext.version < 430)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 310) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 430)) + return identifierOrType(); + return keyword; + + case ATOMIC_UINT: +- if ((parseContext.profile == EEsProfile && parseContext.version >= 310) || +- parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 310) || ++ _parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters)) + return keyword; + return es30ReservedFromGLSL(420); + +@@ -940,15 +918,15 @@ int TScanContext::tokenizeIdentifier() + case RESTRICT: + case READONLY: + case WRITEONLY: +- if (parseContext.profile == EEsProfile && parseContext.version >= 310) ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) + return keyword; +- return es30ReservedFromGLSL(parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store) ? 130 : 420); ++ return es30ReservedFromGLSL(_parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store) ? 130 : 420); + + case VOLATILE: +- if (parseContext.profile == EEsProfile && parseContext.version >= 310) ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) + return keyword; +- if (! parseContext.symbolTable.atBuiltInLevel() && (parseContext.profile == EEsProfile || +- (parseContext.version < 420 && ! parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) ++ if (! _parseContext.symbolTable.atBuiltInLevel() && (_parseContext.profile == EEsProfile || ++ (_parseContext.version < 420 && ! _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) + reservedWord(); + return keyword; + +@@ -957,31 +935,31 @@ int TScanContext::tokenizeIdentifier() + const int numLayoutExts = 2; + const char* layoutExts[numLayoutExts] = { E_GL_ARB_shading_language_420pack, + E_GL_ARB_explicit_attrib_location }; +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 140 && +- ! parseContext.extensionsTurnedOn(numLayoutExts, layoutExts))) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 140 && ++ ! _parseContext.extensionsTurnedOn(numLayoutExts, layoutExts))) + return identifierOrType(); + return keyword; + } + case SHARED: +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 140)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 140)) + return identifierOrType(); + return keyword; + + case PATCH: +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile == EEsProfile && +- (parseContext.version >= 320 || +- parseContext.extensionsTurnedOn(Num_AEP_tessellation_shader, AEP_tessellation_shader))) || +- (parseContext.profile != EEsProfile && parseContext.extensionTurnedOn(E_GL_ARB_tessellation_shader))) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile == EEsProfile && ++ (_parseContext.version >= 320 || ++ _parseContext.extensionsTurnedOn(Num_AEP_tessellation_shader, AEP_tessellation_shader))) || ++ (_parseContext.profile != EEsProfile && _parseContext.extensionTurnedOn(E_GL_ARB_tessellation_shader))) + return keyword; + + return es30ReservedFromGLSL(400); + + case SAMPLE: +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(1, &E_GL_OES_shader_multisample_interpolation)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(1, &E_GL_OES_shader_multisample_interpolation)) + return keyword; + return es30ReservedFromGLSL(400); + +@@ -1035,8 +1013,8 @@ int TScanContext::tokenizeIdentifier() + case IIMAGEBUFFER: + case UIMAGEBUFFER: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + return keyword; + return firstGenerationImage(false); + +@@ -1059,8 +1037,8 @@ int TScanContext::tokenizeIdentifier() + case IIMAGECUBEARRAY: + case UIMAGECUBEARRAY: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) + return keyword; + return secondGenerationImage(); + +@@ -1078,7 +1056,7 @@ int TScanContext::tokenizeIdentifier() + case DVEC3: + case DVEC4: + afterType = true; +- if (parseContext.profile == EEsProfile || parseContext.version < 400) ++ if (_parseContext.profile == EEsProfile || _parseContext.version < 400) + reservedWord(); + return keyword; + +@@ -1091,11 +1069,11 @@ int TScanContext::tokenizeIdentifier() + case U64VEC3: + case U64VEC4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile != EEsProfile && parseContext.version >= 450 && +- (parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int64)))) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && ++ (_parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int64)))) + return keyword; + return identifierOrType(); + +@@ -1108,10 +1086,10 @@ int TScanContext::tokenizeIdentifier() + case U8VEC3: + case U8VEC4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int8)) && +- parseContext.profile != EEsProfile && parseContext.version >= 450)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int8)) && ++ _parseContext.profile != EEsProfile && _parseContext.version >= 450)) + return keyword; + return identifierOrType(); + +@@ -1124,14 +1102,14 @@ int TScanContext::tokenizeIdentifier() + case U16VEC3: + case U16VEC4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile != EEsProfile && parseContext.version >= 450 && ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && + ( + #ifdef AMD_EXTENSIONS +- parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) || ++ _parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) || + #endif +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int16)))) ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int16)))) + return keyword; + return identifierOrType(); + case INT32_T: +@@ -1143,10 +1121,10 @@ int TScanContext::tokenizeIdentifier() + case U32VEC3: + case U32VEC4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int32)) && +- parseContext.profile != EEsProfile && parseContext.version >= 450)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int32)) && ++ _parseContext.profile != EEsProfile && _parseContext.version >= 450)) + return keyword; + return identifierOrType(); + case FLOAT32_T: +@@ -1166,10 +1144,10 @@ int TScanContext::tokenizeIdentifier() + case F32MAT4X3: + case F32MAT4X4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float32)) && +- parseContext.profile != EEsProfile && parseContext.version >= 450)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float32)) && ++ _parseContext.profile != EEsProfile && _parseContext.version >= 450)) + return keyword; + return identifierOrType(); + +@@ -1190,10 +1168,10 @@ int TScanContext::tokenizeIdentifier() + case F64MAT4X3: + case F64MAT4X4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float64)) && +- parseContext.profile != EEsProfile && parseContext.version >= 450)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float64)) && ++ _parseContext.profile != EEsProfile && _parseContext.version >= 450)) + return keyword; + return identifierOrType(); + +@@ -1214,14 +1192,14 @@ int TScanContext::tokenizeIdentifier() + case F16MAT4X3: + case F16MAT4X4: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile != EEsProfile && parseContext.version >= 450 && ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && + ( + #ifdef AMD_EXTENSIONS +- parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) || ++ _parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) || + #endif +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || +- parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float16)))) ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || ++ _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float16)))) + return keyword; + + return identifierOrType(); +@@ -1231,10 +1209,10 @@ int TScanContext::tokenizeIdentifier() + case ISAMPLERCUBEARRAY: + case USAMPLERCUBEARRAY: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) + return keyword; +- if (parseContext.profile == EEsProfile || (parseContext.version < 400 && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_cube_map_array))) ++ if (_parseContext.profile == EEsProfile || (_parseContext.version < 400 && ! _parseContext.extensionTurnedOn(E_GL_ARB_texture_cube_map_array))) + reservedWord(); + return keyword; + +@@ -1271,16 +1249,16 @@ int TScanContext::tokenizeIdentifier() + + case SAMPLERBUFFER: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + return keyword; + return es30ReservedFromGLSL(130); + + case ISAMPLERBUFFER: + case USAMPLERBUFFER: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + return keyword; + return es30ReservedFromGLSL(140); + +@@ -1288,7 +1266,7 @@ int TScanContext::tokenizeIdentifier() + case ISAMPLER2DMS: + case USAMPLER2DMS: + afterType = true; +- if (parseContext.profile == EEsProfile && parseContext.version >= 310) ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) + return keyword; + return es30ReservedFromGLSL(150); + +@@ -1296,30 +1274,30 @@ int TScanContext::tokenizeIdentifier() + case ISAMPLER2DMSARRAY: + case USAMPLER2DMSARRAY: + afterType = true; +- if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || +- parseContext.extensionsTurnedOn(1, &E_GL_OES_texture_storage_multisample_2d_array)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || ++ _parseContext.extensionsTurnedOn(1, &E_GL_OES_texture_storage_multisample_2d_array)) + return keyword; + return es30ReservedFromGLSL(150); + + case SAMPLER1D: + case SAMPLER1DSHADOW: + afterType = true; +- if (parseContext.profile == EEsProfile) ++ if (_parseContext.profile == EEsProfile) + reservedWord(); + return keyword; + + case SAMPLER3D: + afterType = true; +- if (parseContext.profile == EEsProfile && parseContext.version < 300) { +- if (!parseContext.extensionTurnedOn(E_GL_OES_texture_3D)) ++ if (_parseContext.profile == EEsProfile && _parseContext.version < 300) { ++ if (!_parseContext.extensionTurnedOn(E_GL_OES_texture_3D)) + reservedWord(); + } + return keyword; + + case SAMPLER2DSHADOW: + afterType = true; +- if (parseContext.profile == EEsProfile && parseContext.version < 300) { +- if (!parseContext.extensionTurnedOn(E_GL_EXT_shadow_samplers)) ++ if (_parseContext.profile == EEsProfile && _parseContext.version < 300) { ++ if (!_parseContext.extensionTurnedOn(E_GL_EXT_shadow_samplers)) + reservedWord(); + } + return keyword; +@@ -1327,11 +1305,11 @@ int TScanContext::tokenizeIdentifier() + case SAMPLER2DRECT: + case SAMPLER2DRECTSHADOW: + afterType = true; +- if (parseContext.profile == EEsProfile) ++ if (_parseContext.profile == EEsProfile) + reservedWord(); +- else if (parseContext.version < 140 && ! parseContext.symbolTable.atBuiltInLevel() && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_rectangle)) { +- if (parseContext.relaxedErrors()) +- parseContext.requireExtensions(loc, 1, &E_GL_ARB_texture_rectangle, "texture-rectangle sampler keyword"); ++ else if (_parseContext.version < 140 && ! _parseContext.symbolTable.atBuiltInLevel() && ! _parseContext.extensionTurnedOn(E_GL_ARB_texture_rectangle)) { ++ if (_parseContext.relaxedErrors()) ++ _parseContext.requireExtensions(loc, 1, &E_GL_ARB_texture_rectangle, "texture-rectangle sampler keyword"); + else + reservedWord(); + } +@@ -1339,18 +1317,18 @@ int TScanContext::tokenizeIdentifier() + + case SAMPLER1DARRAY: + afterType = true; +- if (parseContext.profile == EEsProfile && parseContext.version == 300) ++ if (_parseContext.profile == EEsProfile && _parseContext.version == 300) + reservedWord(); +- else if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 130)) ++ else if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 130)) + return identifierOrType(); + return keyword; + + case SAMPLEREXTERNALOES: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external) || +- parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external_essl3)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ _parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external) || ++ _parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external_essl3)) + return keyword; + return identifierOrType(); + +@@ -1389,7 +1367,7 @@ int TScanContext::tokenizeIdentifier() + case TEXTURE1DARRAY: + case SAMPLER: + case SAMPLERSHADOW: +- if (parseContext.spvVersion.vulkan > 0) ++ if (_parseContext.spvVersion.vulkan > 0) + return keyword; + else + return identifierOrType(); +@@ -1400,7 +1378,7 @@ int TScanContext::tokenizeIdentifier() + case ISUBPASSINPUTMS: + case USUBPASSINPUT: + case USUBPASSINPUTMS: +- if (parseContext.spvVersion.vulkan > 0) ++ if (_parseContext.spvVersion.vulkan > 0) + return keyword; + else + return identifierOrType(); +@@ -1452,83 +1430,83 @@ int TScanContext::tokenizeIdentifier() + case F16SUBPASSINPUT: + case F16SUBPASSINPUTMS: + afterType = true; +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) && +- parseContext.profile != EEsProfile && parseContext.version >= 450)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) && ++ _parseContext.profile != EEsProfile && _parseContext.version >= 450)) + return keyword; + return identifierOrType(); + #endif + + case NOPERSPECTIVE: + #ifdef NV_EXTENSIONS +- if (parseContext.profile == EEsProfile && parseContext.version >= 300 && +- parseContext.extensionTurnedOn(E_GL_NV_shader_noperspective_interpolation)) ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 300 && ++ _parseContext.extensionTurnedOn(E_GL_NV_shader_noperspective_interpolation)) + return keyword; + #endif + return es30ReservedFromGLSL(130); + + case SMOOTH: +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 130)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 130)) + return identifierOrType(); + return keyword; + + #ifdef AMD_EXTENSIONS + case __EXPLICITINTERPAMD: +- if (parseContext.profile != EEsProfile && parseContext.version >= 450 && +- parseContext.extensionTurnedOn(E_GL_AMD_shader_explicit_vertex_parameter)) ++ if (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && ++ _parseContext.extensionTurnedOn(E_GL_AMD_shader_explicit_vertex_parameter)) + return keyword; + return identifierOrType(); + #endif + + case FLAT: +- if (parseContext.profile == EEsProfile && parseContext.version < 300) ++ if (_parseContext.profile == EEsProfile && _parseContext.version < 300) + reservedWord(); +- else if (parseContext.profile != EEsProfile && parseContext.version < 130) ++ else if (_parseContext.profile != EEsProfile && _parseContext.version < 130) + return identifierOrType(); + return keyword; + + case CENTROID: +- if (parseContext.version < 120) ++ if (_parseContext.version < 120) + return identifierOrType(); + return keyword; + + case PRECISE: +- if ((parseContext.profile == EEsProfile && +- (parseContext.version >= 320 || parseContext.extensionsTurnedOn(Num_AEP_gpu_shader5, AEP_gpu_shader5))) || +- (parseContext.profile != EEsProfile && parseContext.version >= 400)) ++ if ((_parseContext.profile == EEsProfile && ++ (_parseContext.version >= 320 || _parseContext.extensionsTurnedOn(Num_AEP_gpu_shader5, AEP_gpu_shader5))) || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 400)) + return keyword; +- if (parseContext.profile == EEsProfile && parseContext.version == 310) { ++ if (_parseContext.profile == EEsProfile && _parseContext.version == 310) { + reservedWord(); + return keyword; + } + return identifierOrType(); + + case INVARIANT: +- if (parseContext.profile != EEsProfile && parseContext.version < 120) ++ if (_parseContext.profile != EEsProfile && _parseContext.version < 120) + return identifierOrType(); + return keyword; + + case PACKED: +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < 330)) ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < 330)) + return reservedWord(); + return identifierOrType(); + + case RESOURCE: + { +- bool reserved = (parseContext.profile == EEsProfile && parseContext.version >= 300) || +- (parseContext.profile != EEsProfile && parseContext.version >= 420); ++ bool reserved = (_parseContext.profile == EEsProfile && _parseContext.version >= 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 420); + return identifierOrReserved(reserved); + } + case SUPERP: + { +- bool reserved = parseContext.profile == EEsProfile || parseContext.version >= 130; ++ bool reserved = _parseContext.profile == EEsProfile || _parseContext.version >= 130; + return identifierOrReserved(reserved); + } + + default: +- parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); ++ _parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); + return 0; + } + } +@@ -1539,7 +1517,7 @@ int TScanContext::identifierOrType() + if (field) + return IDENTIFIER; + +- parserToken->sType.lex.symbol = parseContext.symbolTable.find(*parserToken->sType.lex.string); ++ parserToken->sType.lex.symbol = _parseContext.symbolTable.find(*parserToken->sType.lex.string); + if ((afterType == false && afterStruct == false) && parserToken->sType.lex.symbol != nullptr) { + if (const TVariable* variable = parserToken->sType.lex.symbol->getAsVariable()) { + if (variable->isUserType()) { +@@ -1558,8 +1536,8 @@ int TScanContext::identifierOrType() + // extension support before the extension is enabled. + int TScanContext::reservedWord() + { +- if (! parseContext.symbolTable.atBuiltInLevel()) +- parseContext.error(loc, "Reserved word.", tokenText, "", ""); ++ if (! _parseContext.symbolTable.atBuiltInLevel()) ++ _parseContext.error(loc, "Reserved word.", tokenText, "", ""); + + return 0; + } +@@ -1572,8 +1550,8 @@ int TScanContext::identifierOrReserved(bool reserved) + return 0; + } + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future reserved keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future reserved keyword", tokenText, ""); + + return identifierOrType(); + } +@@ -1582,16 +1560,16 @@ int TScanContext::identifierOrReserved(bool reserved) + // but then got reserved by ES 3.0. + int TScanContext::es30ReservedFromGLSL(int version) + { +- if (parseContext.symbolTable.atBuiltInLevel()) ++ if (_parseContext.symbolTable.atBuiltInLevel()) + return keyword; + +- if ((parseContext.profile == EEsProfile && parseContext.version < 300) || +- (parseContext.profile != EEsProfile && parseContext.version < version)) { +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "future reserved word in ES 300 and keyword in GLSL", tokenText, ""); ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < version)) { ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "future reserved word in ES 300 and keyword in GLSL", tokenText, ""); + + return identifierOrType(); +- } else if (parseContext.profile == EEsProfile && parseContext.version >= 300) ++ } else if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) + reservedWord(); + + return keyword; +@@ -1601,10 +1579,10 @@ int TScanContext::es30ReservedFromGLSL(int version) + // showed up, both in an es version and a non-ES version. + int TScanContext::nonreservedKeyword(int esVersion, int nonEsVersion) + { +- if ((parseContext.profile == EEsProfile && parseContext.version < esVersion) || +- (parseContext.profile != EEsProfile && parseContext.version < nonEsVersion)) { +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future keyword", tokenText, ""); ++ if ((_parseContext.profile == EEsProfile && _parseContext.version < esVersion) || ++ (_parseContext.profile != EEsProfile && _parseContext.version < nonEsVersion)) { ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future keyword", tokenText, ""); + + return identifierOrType(); + } +@@ -1614,11 +1592,11 @@ int TScanContext::nonreservedKeyword(int esVersion, int nonEsVersion) + + int TScanContext::precisionKeyword() + { +- if (parseContext.profile == EEsProfile || parseContext.version >= 130) ++ if (_parseContext.profile == EEsProfile || _parseContext.version >= 130) + return keyword; + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using ES precision qualifier keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using ES precision qualifier keyword", tokenText, ""); + + return identifierOrType(); + } +@@ -1627,11 +1605,11 @@ int TScanContext::matNxM() + { + afterType = true; + +- if (parseContext.version > 110) ++ if (_parseContext.version > 110) + return keyword; + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future non-square matrix type keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future non-square matrix type keyword", tokenText, ""); + + return identifierOrType(); + } +@@ -1640,56 +1618,56 @@ int TScanContext::dMat() + { + afterType = true; + +- if (parseContext.profile == EEsProfile && parseContext.version >= 300) { ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) { + reservedWord(); + + return keyword; + } + +- if (parseContext.profile != EEsProfile && parseContext.version >= 400) ++ if (_parseContext.profile != EEsProfile && _parseContext.version >= 400) + return keyword; + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future type keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future type keyword", tokenText, ""); + + return identifierOrType(); + } + + int TScanContext::firstGenerationImage(bool inEs310) + { +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile != EEsProfile && (parseContext.version >= 420 || +- parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))) || +- (inEs310 && parseContext.profile == EEsProfile && parseContext.version >= 310)) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile != EEsProfile && (_parseContext.version >= 420 || ++ _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))) || ++ (inEs310 && _parseContext.profile == EEsProfile && _parseContext.version >= 310)) + return keyword; + +- if ((parseContext.profile == EEsProfile && parseContext.version >= 300) || +- (parseContext.profile != EEsProfile && parseContext.version >= 130)) { ++ if ((_parseContext.profile == EEsProfile && _parseContext.version >= 300) || ++ (_parseContext.profile != EEsProfile && _parseContext.version >= 130)) { + reservedWord(); + + return keyword; + } + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future type keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future type keyword", tokenText, ""); + + return identifierOrType(); + } + + int TScanContext::secondGenerationImage() + { +- if (parseContext.profile == EEsProfile && parseContext.version >= 310) { ++ if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) { + reservedWord(); + return keyword; + } + +- if (parseContext.symbolTable.atBuiltInLevel() || +- (parseContext.profile != EEsProfile && +- (parseContext.version >= 420 || parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) ++ if (_parseContext.symbolTable.atBuiltInLevel() || ++ (_parseContext.profile != EEsProfile && ++ (_parseContext.version >= 420 || _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) + return keyword; + +- if (parseContext.forwardCompatible) +- parseContext.warn(loc, "using future type keyword", tokenText, ""); ++ if (_parseContext.forwardCompatible) ++ _parseContext.warn(loc, "using future type keyword", tokenText, ""); + + return identifierOrType(); + } +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h b/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h +index 0cc7ea0a9e..39e7761a62 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h ++++ b/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h +@@ -33,6 +33,9 @@ + // POSSIBILITY OF SUCH DAMAGE. + // + ++#ifndef _MACHINE_INDEPENDENT_SCAN_CONTEXT_H ++#define _MACHINE_INDEPENDENT_SCAN_CONTEXT_H ++ + // + // This holds context specific to the GLSL scanner, which + // sits between the preprocessor scanner and parser. +@@ -51,7 +54,7 @@ class TParserToken; + class TScanContext { + public: + explicit TScanContext(TParseContextBase& pc) : +- parseContext(pc), ++ _parseContext(pc), + afterType(false), afterStruct(false), + field(false) { } + virtual ~TScanContext() { } +@@ -77,7 +80,7 @@ protected: + int firstGenerationImage(bool inEs310); + int secondGenerationImage(); + +- TParseContextBase& parseContext; ++ TParseContextBase& _parseContext; + bool afterType; // true if we've recognized a type, so can only be looking for an identifier + bool afterStruct; // true if we've recognized the STRUCT keyword, so can only be looking for an identifier + bool field; // true if we're on a field, right after a '.' +@@ -90,3 +93,5 @@ protected: + }; + + } // end namespace glslang ++ ++#endif +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp +index 4f39f3453e..7a3061821d 100644 +--- a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp +@@ -233,15 +233,15 @@ bool InitializeSymbolTable(const TString& builtIns, int version, EProfile profil + + intermediate.setSource(source); + +- std::unique_ptr parseContext(CreateParseContext(symbolTable, intermediate, version, profile, source, ++ std::unique_ptr _parseContext(CreateParseContext(symbolTable, intermediate, version, profile, source, + language, infoSink, spvVersion, true, EShMsgDefault, + true)); + + TShader::ForbidIncluder includer; +- TPpContext ppContext(*parseContext, "", includer); +- TScanContext scanContext(*parseContext); +- parseContext->setScanContext(&scanContext); +- parseContext->setPpContext(&ppContext); ++ TPpContext ppContext(*_parseContext, "", includer); ++ TScanContext scanContext(*_parseContext); ++ _parseContext->setScanContext(&scanContext); ++ _parseContext->setPpContext(&ppContext); + + // + // Push the symbol table to give it an initial scope. This +@@ -260,7 +260,7 @@ bool InitializeSymbolTable(const TString& builtIns, int version, EProfile profil + return true; + + TInputScanner input(1, builtInShaders, builtInLengths); +- if (! parseContext->parseShaderStrings(ppContext, input) != 0) { ++ if (! _parseContext->parseShaderStrings(ppContext, input) != 0) { + infoSink.info.message(EPrefixInternalError, "Unable to parse built-ins"); + printf("Unable to parse built-ins\n%s\n", infoSink.info.c_str()); + printf("%s\n", builtInShaders[0]); +@@ -696,7 +696,7 @@ void RecordProcesses(TIntermediate& intermediate, EShMessages messages, const st + // This is the common setup and cleanup code for PreprocessDeferred and + // CompileDeferred. + // It takes any callable with a signature of +-// bool (TParseContextBase& parseContext, TPpContext& ppContext, ++// bool (TParseContextBase& _parseContext, TPpContext& ppContext, + // TInputScanner& input, bool versionWillBeError, + // TSymbolTable& , TIntermediate& , + // EShOptimizationLevel , EShMessages ); +@@ -849,31 +849,31 @@ bool ProcessDeferred( + // Now we can process the full shader under proper symbols and rules. + // + +- std::unique_ptr parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source, ++ std::unique_ptr _parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source, + stage, compiler->infoSink, + spvVersion, forwardCompatible, messages, false, sourceEntryPointName)); +- TPpContext ppContext(*parseContext, names[numPre] ? names[numPre] : "", includer); ++ TPpContext ppContext(*_parseContext, names[numPre] ? names[numPre] : "", includer); + + // only GLSL (bison triggered, really) needs an externally set scan context +- glslang::TScanContext scanContext(*parseContext); ++ glslang::TScanContext scanContext(*_parseContext); + if (source == EShSourceGlsl) +- parseContext->setScanContext(&scanContext); ++ _parseContext->setScanContext(&scanContext); + +- parseContext->setPpContext(&ppContext); +- parseContext->setLimits(*resources); ++ _parseContext->setPpContext(&ppContext); ++ _parseContext->setLimits(*resources); + if (! goodVersion) +- parseContext->addError(); ++ _parseContext->addError(); + if (warnVersionNotFirst) { + TSourceLoc loc; + loc.init(); +- parseContext->warn(loc, "Illegal to have non-comment, non-whitespace tokens before #version", "#version", ""); ++ _parseContext->warn(loc, "Illegal to have non-comment, non-whitespace tokens before #version", "#version", ""); + } + +- parseContext->initializeExtensionBehavior(); ++ _parseContext->initializeExtensionBehavior(); + + // Fill in the strings as outlined above. + std::string preamble; +- parseContext->getPreamble(preamble); ++ _parseContext->getPreamble(preamble); + strings[0] = preamble.c_str(); + lengths[0] = strlen(strings[0]); + names[0] = nullptr; +@@ -892,7 +892,7 @@ bool ProcessDeferred( + // Push a new symbol allocation scope that will get used for the shader's globals. + symbolTable->push(); + +- bool success = processingContext(*parseContext, ppContext, fullInput, ++ bool success = processingContext(*_parseContext, ppContext, fullInput, + versionWillBeError, *symbolTable, + intermediate, optLevel, messages); + return success; +@@ -967,7 +967,7 @@ private: + // It places the result in the "string" argument to its constructor. + struct DoPreprocessing { + explicit DoPreprocessing(std::string* string): outputString(string) {} +- bool operator()(TParseContextBase& parseContext, TPpContext& ppContext, ++ bool operator()(TParseContextBase& _parseContext, TPpContext& ppContext, + TInputScanner& input, bool versionWillBeError, + TSymbolTable&, TIntermediate&, + EShOptimizationLevel, EShMessages) +@@ -977,14 +977,14 @@ struct DoPreprocessing { + static const std::string noSpaceBeforeTokens = ","; + glslang::TPpToken ppToken; + +- parseContext.setScanner(&input); ++ _parseContext.setScanner(&input); + ppContext.setInput(input, versionWillBeError); + + std::string outputBuffer; + SourceLineSynchronizer lineSync( + std::bind(&TInputScanner::getLastValidSourceIndex, &input), &outputBuffer); + +- parseContext.setExtensionCallback([&lineSync, &outputBuffer]( ++ _parseContext.setExtensionCallback([&lineSync, &outputBuffer]( + int line, const char* extension, const char* behavior) { + lineSync.syncToLine(line); + outputBuffer += "#extension "; +@@ -993,7 +993,7 @@ struct DoPreprocessing { + outputBuffer += behavior; + }); + +- parseContext.setLineCallback([&lineSync, &outputBuffer, &parseContext]( ++ _parseContext.setLineCallback([&lineSync, &outputBuffer, &_parseContext]( + int curLineNum, int newLineNum, bool hasSource, int sourceNum, const char* sourceName) { + // SourceNum is the number of the source-string that is being parsed. + lineSync.syncToLine(curLineNum); +@@ -1009,7 +1009,7 @@ struct DoPreprocessing { + outputBuffer += std::to_string(sourceNum); + } + } +- if (parseContext.lineDirectiveShouldSetNextLine()) { ++ if (_parseContext.lineDirectiveShouldSetNextLine()) { + // newLineNum is the new line number for the line following the #line + // directive. So the new line number for the current line is + newLineNum -= 1; +@@ -1019,7 +1019,7 @@ struct DoPreprocessing { + lineSync.setLineNum(newLineNum + 1); + }); + +- parseContext.setVersionCallback( ++ _parseContext.setVersionCallback( + [&lineSync, &outputBuffer](int line, int version, const char* str) { + lineSync.syncToLine(line); + outputBuffer += "#version "; +@@ -1030,7 +1030,7 @@ struct DoPreprocessing { + } + }); + +- parseContext.setPragmaCallback([&lineSync, &outputBuffer]( ++ _parseContext.setPragmaCallback([&lineSync, &outputBuffer]( + int line, const glslang::TVector& ops) { + lineSync.syncToLine(line); + outputBuffer += "#pragma "; +@@ -1039,7 +1039,7 @@ struct DoPreprocessing { + } + }); + +- parseContext.setErrorCallback([&lineSync, &outputBuffer]( ++ _parseContext.setErrorCallback([&lineSync, &outputBuffer]( + int line, const char* errorMessage) { + lineSync.syncToLine(line); + outputBuffer += "#error "; +@@ -1078,10 +1078,10 @@ struct DoPreprocessing { + *outputString = std::move(outputBuffer); + + bool success = true; +- if (parseContext.getNumErrors() > 0) { ++ if (_parseContext.getNumErrors() > 0) { + success = false; +- parseContext.infoSink.info.prefix(EPrefixError); +- parseContext.infoSink.info << parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; ++ _parseContext.infoSink.info.prefix(EPrefixError); ++ _parseContext.infoSink.info << _parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; + } + return success; + } +@@ -1091,28 +1091,28 @@ struct DoPreprocessing { + // DoFullParse is a valid ProcessingConext template argument for fully + // parsing the shader. It populates the "intermediate" with the AST. + struct DoFullParse{ +- bool operator()(TParseContextBase& parseContext, TPpContext& ppContext, ++ bool operator()(TParseContextBase& _parseContext, TPpContext& ppContext, + TInputScanner& fullInput, bool versionWillBeError, + TSymbolTable&, TIntermediate& intermediate, + EShOptimizationLevel optLevel, EShMessages messages) + { + bool success = true; + // Parse the full shader. +- if (! parseContext.parseShaderStrings(ppContext, fullInput, versionWillBeError)) ++ if (! _parseContext.parseShaderStrings(ppContext, fullInput, versionWillBeError)) + success = false; + + if (success && intermediate.getTreeRoot()) { + if (optLevel == EShOptNoGeneration) +- parseContext.infoSink.info.message(EPrefixNone, "No errors. No code generation or linking was requested."); ++ _parseContext.infoSink.info.message(EPrefixNone, "No errors. No code generation or linking was requested."); + else +- success = intermediate.postProcess(intermediate.getTreeRoot(), parseContext.getLanguage()); ++ success = intermediate.postProcess(intermediate.getTreeRoot(), _parseContext.getLanguage()); + } else if (! success) { +- parseContext.infoSink.info.prefix(EPrefixError); +- parseContext.infoSink.info << parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; ++ _parseContext.infoSink.info.prefix(EPrefixError); ++ _parseContext.infoSink.info << _parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; + } + + if (messages & EShMsgAST) +- intermediate.output(parseContext.infoSink, true); ++ intermediate.output(_parseContext.infoSink, true); + + return success; + } +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp +index 8048fa513d..6a2ab91904 100644 +--- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp +@@ -99,12 +99,12 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + // get the macro name + int token = scanToken(ppToken); + if (token != PpAtomIdentifier) { +- parseContext.ppError(ppToken->loc, "must be followed by macro name", "#define", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#define", ""); + return token; + } + if (ppToken->loc.string >= 0) { + // We are in user code; check for reserved name use: +- parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#define"); ++ _parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#define"); + } + + // save the macro name +@@ -119,7 +119,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + if (mac.args.size() == 0 && token == ')') + break; + if (token != PpAtomIdentifier) { +- parseContext.ppError(ppToken->loc, "bad argument", "#define", ""); ++ _parseContext.ppError(ppToken->loc, "bad argument", "#define", ""); + + return token; + } +@@ -130,7 +130,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + bool duplicate = false; + for (size_t a = 0; a < mac.args.size(); ++a) { + if (mac.args[a] == argAtom) { +- parseContext.ppError(ppToken->loc, "duplicate macro parameter", "#define", ""); ++ _parseContext.ppError(ppToken->loc, "duplicate macro parameter", "#define", ""); + duplicate = true; + break; + } +@@ -140,7 +140,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + token = scanToken(ppToken); + } while (token == ','); + if (token != ')') { +- parseContext.ppError(ppToken->loc, "missing parenthesis", "#define", ""); ++ _parseContext.ppError(ppToken->loc, "missing parenthesis", "#define", ""); + + return token; + } +@@ -165,10 +165,10 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + // "Two replacement lists are identical if and only if the preprocessing tokens in both have the same number, + // ordering, spelling, and white-space separation, where all white-space separations are considered identical." + if (existing->args.size() != mac.args.size() || existing->emptyArgs != mac.emptyArgs) +- parseContext.ppError(defineLoc, "Macro redefined; different number of arguments:", "#define", atomStrings.getString(defAtom)); ++ _parseContext.ppError(defineLoc, "Macro redefined; different number of arguments:", "#define", atomStrings.getString(defAtom)); + else { + if (existing->args != mac.args) +- parseContext.ppError(defineLoc, "Macro redefined; different argument names:", "#define", atomStrings.getString(defAtom)); ++ _parseContext.ppError(defineLoc, "Macro redefined; different argument names:", "#define", atomStrings.getString(defAtom)); + existing->body.reset(); + mac.body.reset(); + int newToken; +@@ -176,10 +176,10 @@ int TPpContext::CPPdefine(TPpToken* ppToken) + int oldToken; + TPpToken oldPpToken; + TPpToken newPpToken; +- oldToken = existing->body.getToken(parseContext, &oldPpToken); +- newToken = mac.body.getToken(parseContext, &newPpToken); ++ oldToken = existing->body.getToken(_parseContext, &oldPpToken); ++ newToken = mac.body.getToken(_parseContext, &newPpToken); + if (oldToken != newToken || oldPpToken != newPpToken) { +- parseContext.ppError(defineLoc, "Macro redefined; different substitutions:", "#define", atomStrings.getString(defAtom)); ++ _parseContext.ppError(defineLoc, "Macro redefined; different substitutions:", "#define", atomStrings.getString(defAtom)); + break; + } + } while (newToken > 0); +@@ -197,19 +197,19 @@ int TPpContext::CPPundef(TPpToken* ppToken) + { + int token = scanToken(ppToken); + if (token != PpAtomIdentifier) { +- parseContext.ppError(ppToken->loc, "must be followed by macro name", "#undef", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#undef", ""); + + return token; + } + +- parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#undef"); ++ _parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#undef"); + + MacroSymbol* macro = lookupMacroDef(atomStrings.getAtom(ppToken->name)); + if (macro != nullptr) + macro->undef = 1; + token = scanToken(ppToken); + if (token != '\n') +- parseContext.ppError(ppToken->loc, "can only be followed by a single macro name", "#undef", ""); ++ _parseContext.ppError(ppToken->loc, "can only be followed by a single macro name", "#undef", ""); + + return token; + } +@@ -243,7 +243,7 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) + if (nextAtom == PpAtomIf || nextAtom == PpAtomIfdef || nextAtom == PpAtomIfndef) { + depth++; + if (ifdepth >= maxIfNesting || elsetracker >= maxIfNesting) { +- parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if/#ifdef/#ifndef", ""); ++ _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if/#ifdef/#ifndef", ""); + return EndOfInput; + } else { + ifdepth++; +@@ -269,7 +269,7 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) + break; + } else if (nextAtom == PpAtomElif) { + if (elseSeen[elsetracker]) +- parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); ++ _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + /* we decrement ifdepth here, because CPPif will increment + * it and we really want to leave it alone */ + if (ifdepth > 0) { +@@ -282,13 +282,13 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) + } + } else if (nextAtom == PpAtomElse) { + if (elseSeen[elsetracker]) +- parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); ++ _parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); + else + elseSeen[elsetracker] = true; + token = extraTokenCheck(nextAtom, ppToken, scanToken(ppToken)); + } else if (nextAtom == PpAtomElif) { + if (elseSeen[elsetracker]) +- parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); ++ _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + } + } + +@@ -315,10 +315,10 @@ int TPpContext::extraTokenCheck(int contextAtom, TPpToken* ppToken, int token) + else + label = ""; + +- if (parseContext.relaxedErrors()) +- parseContext.ppWarn(ppToken->loc, message, label, ""); ++ if (_parseContext.relaxedErrors()) ++ _parseContext.ppWarn(ppToken->loc, message, label, ""); + else +- parseContext.ppError(ppToken->loc, message, label, ""); ++ _parseContext.ppError(ppToken->loc, message, label, ""); + + while (token != '\n' && token != EndOfInput) + token = scanToken(ppToken); +@@ -399,12 +399,12 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + TSourceLoc loc = ppToken->loc; // because we sometimes read the newline before reporting the error + if (token == PpAtomIdentifier) { + if (strcmp("defined", ppToken->name) == 0) { +- if (! parseContext.isReadingHLSL() && isMacroInput()) { +- if (parseContext.relaxedErrors()) +- parseContext.ppWarn(ppToken->loc, "nonportable when expanded from macros for preprocessor expression", ++ if (! _parseContext.isReadingHLSL() && isMacroInput()) { ++ if (_parseContext.relaxedErrors()) ++ _parseContext.ppWarn(ppToken->loc, "nonportable when expanded from macros for preprocessor expression", + "defined", ""); + else +- parseContext.ppError(ppToken->loc, "cannot use in preprocessor expression when expanded from macros", ++ _parseContext.ppError(ppToken->loc, "cannot use in preprocessor expression when expanded from macros", + "defined", ""); + } + bool needclose = 0; +@@ -414,7 +414,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + token = scanToken(ppToken); + } + if (token != PpAtomIdentifier) { +- parseContext.ppError(loc, "incorrect directive, expected identifier", "preprocessor evaluation", ""); ++ _parseContext.ppError(loc, "incorrect directive, expected identifier", "preprocessor evaluation", ""); + err = true; + res = 0; + +@@ -426,7 +426,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + token = scanToken(ppToken); + if (needclose) { + if (token != ')') { +- parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); ++ _parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); + err = true; + res = 0; + +@@ -446,7 +446,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + token = eval(token, MIN_PRECEDENCE, shortCircuit, res, err, ppToken); + if (! err) { + if (token != ')') { +- parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); ++ _parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); + err = true; + res = 0; + +@@ -465,7 +465,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + token = eval(token, UNARY, shortCircuit, res, err, ppToken); + res = unop[op].op(res); + } else { +- parseContext.ppError(loc, "bad expression", "preprocessor evaluation", ""); ++ _parseContext.ppError(loc, "bad expression", "preprocessor evaluation", ""); + err = true; + res = 0; + +@@ -501,7 +501,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo + + if (binop[op].op == op_div || binop[op].op == op_mod) { + if (res == 0) { +- parseContext.ppError(loc, "division by 0", "preprocessor evaluation", ""); ++ _parseContext.ppError(loc, "division by 0", "preprocessor evaluation", ""); + res = 1; + } + } +@@ -517,19 +517,19 @@ int TPpContext::evalToToken(int token, bool shortCircuit, int& res, bool& err, T + while (token == PpAtomIdentifier && strcmp("defined", ppToken->name) != 0) { + int macroReturn = MacroExpand(ppToken, true, false); + if (macroReturn == 0) { +- parseContext.ppError(ppToken->loc, "can't evaluate expression", "preprocessor evaluation", ""); ++ _parseContext.ppError(ppToken->loc, "can't evaluate expression", "preprocessor evaluation", ""); + err = true; + res = 0; + token = scanToken(ppToken); + break; + } + if (macroReturn == -1) { +- if (! shortCircuit && parseContext.profile == EEsProfile) { ++ if (! shortCircuit && _parseContext.profile == EEsProfile) { + const char* message = "undefined macro in expression not allowed in es profile"; +- if (parseContext.relaxedErrors()) +- parseContext.ppWarn(ppToken->loc, message, "preprocessor evaluation", ppToken->name); ++ if (_parseContext.relaxedErrors()) ++ _parseContext.ppWarn(ppToken->loc, message, "preprocessor evaluation", ppToken->name); + else +- parseContext.ppError(ppToken->loc, message, "preprocessor evaluation", ppToken->name); ++ _parseContext.ppError(ppToken->loc, message, "preprocessor evaluation", ppToken->name); + } + } + token = scanToken(ppToken); +@@ -543,7 +543,7 @@ int TPpContext::CPPif(TPpToken* ppToken) + { + int token = scanToken(ppToken); + if (ifdepth >= maxIfNesting || elsetracker >= maxIfNesting) { +- parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if", ""); ++ _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if", ""); + return EndOfInput; + } else { + elsetracker++; +@@ -564,7 +564,7 @@ int TPpContext::CPPifdef(int defined, TPpToken* ppToken) + { + int token = scanToken(ppToken); + if (ifdepth > maxIfNesting || elsetracker > maxIfNesting) { +- parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#ifdef", ""); ++ _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#ifdef", ""); + return EndOfInput; + } else { + elsetracker++; +@@ -573,14 +573,14 @@ int TPpContext::CPPifdef(int defined, TPpToken* ppToken) + + if (token != PpAtomIdentifier) { + if (defined) +- parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifdef", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifdef", ""); + else +- parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifndef", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifndef", ""); + } else { + MacroSymbol* macro = lookupMacroDef(atomStrings.getAtom(ppToken->name)); + token = scanToken(ppToken); + if (token != '\n') { +- parseContext.ppError(ppToken->loc, "unexpected tokens following #ifdef directive - expected a newline", "#ifdef", ""); ++ _parseContext.ppError(ppToken->loc, "unexpected tokens following #ifdef directive - expected a newline", "#ifdef", ""); + while (token != '\n' && token != EndOfInput) + token = scanToken(ppToken); + } +@@ -607,7 +607,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) + // otherwise ppToken already has the header name and it was "header-name" style + + if (token != PpAtomConstString) { +- parseContext.ppError(directiveLoc, "must be followed by a header name", "#include", ""); ++ _parseContext.ppError(directiveLoc, "must be followed by a header name", "#include", ""); + return token; + } + +@@ -618,9 +618,9 @@ int TPpContext::CPPinclude(TPpToken* ppToken) + token = scanToken(ppToken); + if (token != '\n') { + if (token == EndOfInput) +- parseContext.ppError(ppToken->loc, "expected newline after header name:", "#include", "%s", filename.c_str()); ++ _parseContext.ppError(ppToken->loc, "expected newline after header name:", "#include", "%s", filename.c_str()); + else +- parseContext.ppError(ppToken->loc, "extra content after header name:", "#include", "%s", filename.c_str()); ++ _parseContext.ppError(ppToken->loc, "extra content after header name:", "#include", "%s", filename.c_str()); + return token; + } + +@@ -640,7 +640,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) + if (res != nullptr && !res->headerName.empty()) { + if (res->headerData != nullptr && res->headerLength > 0) { + // path for processing one or more tokens from an included header, hand off 'res' +- const bool forNextLine = parseContext.lineDirectiveShouldSetNextLine(); ++ const bool forNextLine = _parseContext.lineDirectiveShouldSetNextLine(); + std::ostringstream prologue; + std::ostringstream epilogue; + prologue << "#line " << forNextLine << " " << "\"" << res->headerName << "\"\n"; +@@ -648,7 +648,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) + "#line " << directiveLoc.line + forNextLine << " " << directiveLoc.getStringNameOrNum() << "\n"; + pushInput(new TokenizableIncludeFile(directiveLoc, prologue.str(), res, epilogue.str(), this)); + // There's no "current" location anymore. +- parseContext.setCurrentColumn(0); ++ _parseContext.setCurrentColumn(0); + } else { + // things are okay, but there is nothing to process + includer.releaseInclude(res); +@@ -658,7 +658,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) + std::string message = + res != nullptr ? std::string(res->headerData, res->headerLength) + : std::string("Could not process include directive"); +- parseContext.ppError(directiveLoc, message.c_str(), "#include", "for header name: %s", filename.c_str()); ++ _parseContext.ppError(directiveLoc, message.c_str(), "#include", "for header name: %s", filename.c_str()); + includer.releaseInclude(res); + } + +@@ -675,7 +675,7 @@ int TPpContext::CPPline(TPpToken* ppToken) + int token = scanToken(ppToken); + const TSourceLoc directiveLoc = ppToken->loc; + if (token == '\n') { +- parseContext.ppError(ppToken->loc, "must by followed by an integral literal", "#line", ""); ++ _parseContext.ppError(ppToken->loc, "must by followed by an integral literal", "#line", ""); + return token; + } + +@@ -692,31 +692,31 @@ int TPpContext::CPPline(TPpToken* ppToken) + if (token == '\n') + ++lineRes; + +- if (parseContext.lineDirectiveShouldSetNextLine()) ++ if (_parseContext.lineDirectiveShouldSetNextLine()) + --lineRes; +- parseContext.setCurrentLine(lineRes); ++ _parseContext.setCurrentLine(lineRes); + + if (token != '\n') { + if (token == PpAtomConstString) { +- parseContext.ppRequireExtensions(directiveLoc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based #line"); ++ _parseContext.ppRequireExtensions(directiveLoc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based #line"); + // We need to save a copy of the string instead of pointing + // to the name field of the token since the name field + // will likely be overwritten by the next token scan. + sourceName = atomStrings.getString(atomStrings.getAddAtom(ppToken->name)); +- parseContext.setCurrentSourceName(sourceName); ++ _parseContext.setCurrentSourceName(sourceName); + hasFile = true; + token = scanToken(ppToken); + } else { + token = eval(token, MIN_PRECEDENCE, false, fileRes, fileErr, ppToken); + if (! fileErr) { +- parseContext.setCurrentString(fileRes); ++ _parseContext.setCurrentString(fileRes); + hasFile = true; + } + } + } + } + if (!fileErr && !lineErr) { +- parseContext.notifyLineDirective(directiveLoc.line, lineToken, hasFile, fileRes, sourceName); ++ _parseContext.notifyLineDirective(directiveLoc.line, lineToken, hasFile, fileRes, sourceName); + } + token = extraTokenCheck(PpAtomLine, ppToken, token); + +@@ -745,9 +745,9 @@ int TPpContext::CPPerror(TPpToken* ppToken) + message.append(" "); + token = scanToken(ppToken); + } +- parseContext.notifyErrorDirective(loc.line, message.c_str()); ++ _parseContext.notifyErrorDirective(loc.line, message.c_str()); + // store this msg into the shader's information log..set the Compile Error flag!!!! +- parseContext.ppError(loc, message.c_str(), "#error", ""); ++ _parseContext.ppError(loc, message.c_str(), "#error", ""); + + return '\n'; + } +@@ -785,9 +785,9 @@ int TPpContext::CPPpragma(TPpToken* ppToken) + } + + if (token == EndOfInput) +- parseContext.ppError(loc, "directive must end with a newline", "#pragma", ""); ++ _parseContext.ppError(loc, "directive must end with a newline", "#pragma", ""); + else +- parseContext.handlePragma(loc, tokens); ++ _parseContext.handlePragma(loc, tokens); + + return token; + } +@@ -798,21 +798,21 @@ int TPpContext::CPPversion(TPpToken* ppToken) + int token = scanToken(ppToken); + + if (errorOnVersion || versionSeen) { +- if (parseContext.isReadingHLSL()) +- parseContext.ppError(ppToken->loc, "invalid preprocessor command", "#version", ""); ++ if (_parseContext.isReadingHLSL()) ++ _parseContext.ppError(ppToken->loc, "invalid preprocessor command", "#version", ""); + else +- parseContext.ppError(ppToken->loc, "must occur first in shader", "#version", ""); ++ _parseContext.ppError(ppToken->loc, "must occur first in shader", "#version", ""); + } + versionSeen = true; + + if (token == '\n') { +- parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); + + return token; + } + + if (token != PpAtomConstInt) +- parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); ++ _parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); + + ppToken->ival = atoi(ppToken->name); + int versionNumber = ppToken->ival; +@@ -820,21 +820,21 @@ int TPpContext::CPPversion(TPpToken* ppToken) + token = scanToken(ppToken); + + if (token == '\n') { +- parseContext.notifyVersion(line, versionNumber, nullptr); ++ _parseContext.notifyVersion(line, versionNumber, nullptr); + return token; + } else { + int profileAtom = atomStrings.getAtom(ppToken->name); + if (profileAtom != PpAtomCore && + profileAtom != PpAtomCompatibility && + profileAtom != PpAtomEs) +- parseContext.ppError(ppToken->loc, "bad profile name; use es, core, or compatibility", "#version", ""); +- parseContext.notifyVersion(line, versionNumber, ppToken->name); ++ _parseContext.ppError(ppToken->loc, "bad profile name; use es, core, or compatibility", "#version", ""); ++ _parseContext.notifyVersion(line, versionNumber, ppToken->name); + token = scanToken(ppToken); + + if (token == '\n') + return token; + else +- parseContext.ppError(ppToken->loc, "bad tokens following profile -- expected newline", "#version", ""); ++ _parseContext.ppError(ppToken->loc, "bad tokens following profile -- expected newline", "#version", ""); + } + + return token; +@@ -848,36 +848,36 @@ int TPpContext::CPPextension(TPpToken* ppToken) + char extensionName[MaxTokenLength + 1]; + + if (token=='\n') { +- parseContext.ppError(ppToken->loc, "extension name not specified", "#extension", ""); ++ _parseContext.ppError(ppToken->loc, "extension name not specified", "#extension", ""); + return token; + } + + if (token != PpAtomIdentifier) +- parseContext.ppError(ppToken->loc, "extension name expected", "#extension", ""); ++ _parseContext.ppError(ppToken->loc, "extension name expected", "#extension", ""); + + assert(strlen(ppToken->name) <= MaxTokenLength); + strcpy(extensionName, ppToken->name); + + token = scanToken(ppToken); + if (token != ':') { +- parseContext.ppError(ppToken->loc, "':' missing after extension name", "#extension", ""); ++ _parseContext.ppError(ppToken->loc, "':' missing after extension name", "#extension", ""); + return token; + } + + token = scanToken(ppToken); + if (token != PpAtomIdentifier) { +- parseContext.ppError(ppToken->loc, "behavior for extension not specified", "#extension", ""); ++ _parseContext.ppError(ppToken->loc, "behavior for extension not specified", "#extension", ""); + return token; + } + +- parseContext.updateExtensionBehavior(line, extensionName, ppToken->name); +- parseContext.notifyExtensionDirective(line, extensionName, ppToken->name); ++ _parseContext.updateExtensionBehavior(line, extensionName, ppToken->name); ++ _parseContext.notifyExtensionDirective(line, extensionName, ppToken->name); + + token = scanToken(ppToken); + if (token == '\n') + return token; + else +- parseContext.ppError(ppToken->loc, "extra tokens -- expected newline", "#extension",""); ++ _parseContext.ppError(ppToken->loc, "extra tokens -- expected newline", "#extension",""); + + return token; + } +@@ -893,18 +893,18 @@ int TPpContext::readCPPline(TPpToken* ppToken) + break; + case PpAtomElse: + if (elseSeen[elsetracker]) +- parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); ++ _parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); + elseSeen[elsetracker] = true; + if (ifdepth == 0) +- parseContext.ppError(ppToken->loc, "mismatched statements", "#else", ""); ++ _parseContext.ppError(ppToken->loc, "mismatched statements", "#else", ""); + token = extraTokenCheck(PpAtomElse, ppToken, scanToken(ppToken)); + token = CPPelse(0, ppToken); + break; + case PpAtomElif: + if (ifdepth == 0) +- parseContext.ppError(ppToken->loc, "mismatched statements", "#elif", ""); ++ _parseContext.ppError(ppToken->loc, "mismatched statements", "#elif", ""); + if (elseSeen[elsetracker]) +- parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); ++ _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + // this token is really a dont care, but we still need to eat the tokens + token = scanToken(ppToken); + while (token != '\n' && token != EndOfInput) +@@ -913,7 +913,7 @@ int TPpContext::readCPPline(TPpToken* ppToken) + break; + case PpAtomEndif: + if (ifdepth == 0) +- parseContext.ppError(ppToken->loc, "mismatched statements", "#endif", ""); ++ _parseContext.ppError(ppToken->loc, "mismatched statements", "#endif", ""); + else { + elseSeen[elsetracker] = false; + --elsetracker; +@@ -931,8 +931,8 @@ int TPpContext::readCPPline(TPpToken* ppToken) + token = CPPifdef(0, ppToken); + break; + case PpAtomInclude: +- if(!parseContext.isReadingHLSL()) { +- parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_include_directive, "#include"); ++ if(!_parseContext.isReadingHLSL()) { ++ _parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_include_directive, "#include"); + } + token = CPPinclude(ppToken); + break; +@@ -955,11 +955,11 @@ int TPpContext::readCPPline(TPpToken* ppToken) + token = CPPextension(ppToken); + break; + default: +- parseContext.ppError(ppToken->loc, "invalid directive:", "#", ppToken->name); ++ _parseContext.ppError(ppToken->loc, "invalid directive:", "#", ppToken->name); + break; + } + } else if (token != '\n' && token != EndOfInput) +- parseContext.ppError(ppToken->loc, "invalid directive", "#", ""); ++ _parseContext.ppError(ppToken->loc, "invalid directive", "#", ""); + + while (token != '\n' && token != EndOfInput) + token = scanToken(ppToken); +@@ -986,7 +986,7 @@ int TPpContext::scanHeaderName(TPpToken* ppToken, char delimit) + if (ch == delimit) { + ppToken->name[len] = '\0'; + if (tooLong) +- parseContext.ppError(ppToken->loc, "header name too long", "", ""); ++ _parseContext.ppError(ppToken->loc, "header name too long", "", ""); + return PpAtomConstString; + } else if (ch == EndOfInput) + return EndOfInput; +@@ -1038,7 +1038,7 @@ int TPpContext::tMacroInput::scan(TPpToken* ppToken) + { + int token; + do { +- token = mac->body.getToken(pp->parseContext, ppToken); ++ token = mac->body.getToken(pp->_parseContext, ppToken); + } while (token == ' '); // handle white space in macro + + // Hash operators basically turn off a round of macro substitution +@@ -1075,7 +1075,7 @@ int TPpContext::tMacroInput::scan(TPpToken* ppToken) + } + + // HLSL does expand macros before concatenation +- if (pasting && pp->parseContext.isReadingHLSL()) ++ if (pasting && pp->_parseContext.isReadingHLSL()) + pasting = false; + + // TODO: preprocessor: properly handle whitespace (or lack of it) between tokens when expanding +@@ -1128,22 +1128,22 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka + int macroAtom = atomStrings.getAtom(ppToken->name); + switch (macroAtom) { + case PpAtomLineMacro: +- ppToken->ival = parseContext.getCurrentLoc().line; ++ ppToken->ival = _parseContext.getCurrentLoc().line; + snprintf(ppToken->name, sizeof(ppToken->name), "%d", ppToken->ival); + UngetToken(PpAtomConstInt, ppToken); + return 1; + + case PpAtomFileMacro: { +- if (parseContext.getCurrentLoc().name) +- parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based __FILE__"); +- ppToken->ival = parseContext.getCurrentLoc().string; ++ if (_parseContext.getCurrentLoc().name) ++ _parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based __FILE__"); ++ ppToken->ival = _parseContext.getCurrentLoc().string; + snprintf(ppToken->name, sizeof(ppToken->name), "%s", ppToken->loc.getStringNameOrNum().c_str()); + UngetToken(PpAtomConstInt, ppToken); + return 1; + } + + case PpAtomVersionMacro: +- ppToken->ival = parseContext.version; ++ ppToken->ival = _parseContext.version; + snprintf(ppToken->name, sizeof(ppToken->name), "%d", ppToken->ival); + UngetToken(PpAtomConstInt, ppToken); + return 1; +@@ -1197,20 +1197,20 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka + while (1) { + token = scanToken(ppToken); + if (token == EndOfInput || token == tMarkerInput::marker) { +- parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); + delete in; + return 0; + } + if (token == '\n') { + if (! newLineOkay) { +- parseContext.ppError(loc, "End of line in macro substitution:", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(loc, "End of line in macro substitution:", "macro expansion", atomStrings.getString(macroAtom)); + delete in; + return 0; + } + continue; + } + if (token == '#') { +- parseContext.ppError(ppToken->loc, "unexpected '#'", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(ppToken->loc, "unexpected '#'", "macro expansion", atomStrings.getString(macroAtom)); + delete in; + return 0; + } +@@ -1235,7 +1235,7 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka + } while (arg < in->mac->args.size()); + + if (arg < in->mac->args.size()) +- parseContext.ppError(loc, "Too few args in Macro", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(loc, "Too few args in Macro", "macro expansion", atomStrings.getString(macroAtom)); + else if (token != ')') { + depth=0; + while (token != EndOfInput && (depth > 0 || token != ')')) { +@@ -1247,11 +1247,11 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka + } + + if (token == EndOfInput) { +- parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); + delete in; + return 0; + } +- parseContext.ppError(loc, "Too many args in macro", "macro expansion", atomStrings.getString(macroAtom)); ++ _parseContext.ppError(loc, "Too many args in macro", "macro expansion", atomStrings.getString(macroAtom)); + } + + // We need both expanded and non-expanded forms of the argument, for whether or +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp +index c89b37688a..83c9d7e8e1 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp +@@ -84,7 +84,7 @@ NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + namespace glslang { + + TPpContext::TPpContext(TParseContextBase& pc, const std::string& rootFileName, TShader::Includer& inclr) : +- preamble(0), strings(0), previous_token('\n'), parseContext(pc), includer(inclr), inComment(false), ++ preamble(0), strings(0), previous_token('\n'), _parseContext(pc), includer(inclr), inComment(false), + rootFileName(rootFileName), + currentSourceFile(rootFileName) + { +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h +index b3a39c5cbc..6324923d75 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h ++++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h +@@ -291,7 +291,7 @@ protected: + + // Scanner data: + int previous_token; +- TParseContextBase& parseContext; ++ TParseContextBase& _parseContext; + + // Get the next token from *stack* of input sources, popping input sources + // that are out of tokens, down until an input source is found that has a token. +@@ -411,7 +411,7 @@ protected: + class tTokenInput : public tInput { + public: + tTokenInput(TPpContext* pp, TokenStream* t, bool prepasting) : tInput(pp), tokens(t), lastTokenPastes(prepasting) { } +- virtual int scan(TPpToken *ppToken) override { return tokens->getToken(pp->parseContext, ppToken); } ++ virtual int scan(TPpToken *ppToken) override { return tokens->getToken(pp->_parseContext, ppToken); } + virtual int getch() override { assert(0); return EndOfInput; } + virtual void ungetch() override { assert(0); } + virtual bool peekPasting() override { return tokens->peekTokenizedPasting(lastTokenPastes); } +@@ -450,7 +450,7 @@ protected: + // Move past escaped newlines, as many as sequentially exist + do { + if (input->peek() == '\r' || input->peek() == '\n') { +- bool allowed = pp->parseContext.lineContinuationCheck(input->getSourceLoc(), pp->inComment); ++ bool allowed = pp->_parseContext.lineContinuationCheck(input->getSourceLoc(), pp->inComment); + if (! allowed && pp->inComment) + return '\\'; + +@@ -553,14 +553,14 @@ protected: + + void notifyActivated() override + { +- prevScanner = pp->parseContext.getScanner(); +- pp->parseContext.setScanner(&scanner); ++ prevScanner = pp->_parseContext.getScanner(); ++ pp->_parseContext.setScanner(&scanner); + pp->push_include(includedFile_); + } + + void notifyDeleted() override + { +- pp->parseContext.setScanner(prevScanner); ++ pp->_parseContext.setScanner(prevScanner); + pp->pop_include(); + } + +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp +index 0c620a5f5b..c73d74178d 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp +@@ -134,18 +134,18 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + int firstDecimal = len; + + // 1.#INF or -1.#INF +- if (ch == '#' && (ifdepth > 0 || parseContext.intermediate.getSource() == EShSourceHlsl)) { ++ if (ch == '#' && (ifdepth > 0 || _parseContext.intermediate.getSource() == EShSourceHlsl)) { + if ((len < 2) || + (len == 2 && ppToken->name[0] != '1') || + (len == 3 && ppToken->name[1] != '1' && !(ppToken->name[0] == '-' || ppToken->name[0] == '+')) || + (len > 3)) +- parseContext.ppError(ppToken->loc, "unexpected use of", "#", ""); ++ _parseContext.ppError(ppToken->loc, "unexpected use of", "#", ""); + else { + // we have 1.# or -1.# or +1.#, check for 'INF' + if ((ch = getChar()) != 'I' || + (ch = getChar()) != 'N' || + (ch = getChar()) != 'F') +- parseContext.ppError(ppToken->loc, "expected 'INF'", "#", ""); ++ _parseContext.ppError(ppToken->loc, "expected 'INF'", "#", ""); + else { + // we have [+-].#INF, and we are targeting IEEE 754, so wrap it up: + saveName('I'); +@@ -213,7 +213,7 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + ch = getChar(); + } + } else { +- parseContext.ppError(ppToken->loc, "bad character in float exponent", "", ""); ++ _parseContext.ppError(ppToken->loc, "bad character in float exponent", "", ""); + } + } + +@@ -249,11 +249,11 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + bool isDouble = false; + bool isFloat16 = false; + if (ch == 'l' || ch == 'L') { +- if (ifdepth == 0 && parseContext.intermediate.getSource() == EShSourceGlsl) +- parseContext.doubleCheck(ppToken->loc, "double floating-point suffix"); ++ if (ifdepth == 0 && _parseContext.intermediate.getSource() == EShSourceGlsl) ++ _parseContext.doubleCheck(ppToken->loc, "double floating-point suffix"); + if (ifdepth == 0 && !hasDecimalOrExponent) +- parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); +- if (parseContext.intermediate.getSource() == EShSourceGlsl) { ++ _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); ++ if (_parseContext.intermediate.getSource() == EShSourceGlsl) { + int ch2 = getChar(); + if (ch2 != 'f' && ch2 != 'F') { + ungetChar(); +@@ -263,16 +263,16 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + saveName(ch2); + isDouble = true; + } +- } else if (parseContext.intermediate.getSource() == EShSourceHlsl) { ++ } else if (_parseContext.intermediate.getSource() == EShSourceHlsl) { + saveName(ch); + isDouble = true; + } + } else if (ch == 'h' || ch == 'H') { +- if (ifdepth == 0 && parseContext.intermediate.getSource() == EShSourceGlsl) +- parseContext.float16Check(ppToken->loc, "half floating-point suffix"); ++ if (ifdepth == 0 && _parseContext.intermediate.getSource() == EShSourceGlsl) ++ _parseContext.float16Check(ppToken->loc, "half floating-point suffix"); + if (ifdepth == 0 && !hasDecimalOrExponent) +- parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); +- if (parseContext.intermediate.getSource() == EShSourceGlsl) { ++ _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); ++ if (_parseContext.intermediate.getSource() == EShSourceGlsl) { + int ch2 = getChar(); + if (ch2 != 'f' && ch2 != 'F') { + ungetChar(); +@@ -282,17 +282,17 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + saveName(ch2); + isFloat16 = true; + } +- } else if (parseContext.intermediate.getSource() == EShSourceHlsl) { ++ } else if (_parseContext.intermediate.getSource() == EShSourceHlsl) { + saveName(ch); + isFloat16 = true; + } + } else if (ch == 'f' || ch == 'F') { + if (ifdepth == 0) +- parseContext.profileRequires(ppToken->loc, EEsProfile, 300, nullptr, "floating-point suffix"); +- if (ifdepth == 0 && !parseContext.relaxedErrors()) +- parseContext.profileRequires(ppToken->loc, ~EEsProfile, 120, nullptr, "floating-point suffix"); ++ _parseContext.profileRequires(ppToken->loc, EEsProfile, 300, nullptr, "floating-point suffix"); ++ if (ifdepth == 0 && !_parseContext.relaxedErrors()) ++ _parseContext.profileRequires(ppToken->loc, ~EEsProfile, 120, nullptr, "floating-point suffix"); + if (ifdepth == 0 && !hasDecimalOrExponent) +- parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); ++ _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); + saveName(ch); + } else + ungetChar(); +@@ -301,7 +301,7 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) + + if (len > MaxTokenLength) { + len = MaxTokenLength; +- parseContext.ppError(ppToken->loc, "float literal too long", "", ""); ++ _parseContext.ppError(ppToken->loc, "float literal too long", "", ""); + } + ppToken->name[len] = '\0'; + +@@ -349,7 +349,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) + ppToken->name[0] = 0; + ppToken->ival = 0; + +- if (parseContext.intermediate.getSource() != EShSourceHlsl) { ++ if (_parseContext.intermediate.getSource() != EShSourceHlsl) { + // illegal, except in macro definition, for which case we report the character + return '\''; + } +@@ -358,7 +358,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) + switch (ch) { + case '\'': + // As empty sequence: '' +- parseContext.ppError(ppToken->loc, "unexpected", "\'", ""); ++ _parseContext.ppError(ppToken->loc, "unexpected", "\'", ""); + return PpAtomConstInt; + case '\\': + // As escape sequence: '\XXX' +@@ -386,7 +386,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) + break; + case 'x': + case '0': +- parseContext.ppError(ppToken->loc, "octal and hex sequences not supported", "\\", ""); ++ _parseContext.ppError(ppToken->loc, "octal and hex sequences not supported", "\\", ""); + break; + default: + // This catches '\'', '\"', '\?', etc. +@@ -404,7 +404,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) + ppToken->name[1] = '\0'; + ch = getChar(); + if (ch != '\'') { +- parseContext.ppError(ppToken->loc, "expected", "\'", ""); ++ _parseContext.ppError(ppToken->loc, "expected", "\'", ""); + // Look ahead for a closing ' + do { + ch = getChar(); +@@ -452,7 +452,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + ch = getch(); + } + +- ppToken->loc = pp->parseContext.getCurrentLoc(); ++ ppToken->loc = pp->_parseContext.getCurrentLoc(); + len = 0; + switch (ch) { + default: +@@ -479,7 +479,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + ch = getch(); + } else { + if (! AlreadyComplained) { +- pp->parseContext.ppError(ppToken->loc, "name too long", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "name too long", "", ""); + AlreadyComplained = 1; + } + ch = getch(); +@@ -522,14 +522,14 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + } else if (ch >= 'a' && ch <= 'f') { + ii = ch - 'a' + 10; + } else +- pp->parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); + ival = (ival << 4) | ii; + } else { + if (! AlreadyComplained) { + if(len < MaxTokenLength) +- pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); + else +- pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too long", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too long", "", ""); + AlreadyComplained = 1; + } + ival = 0xffffffffffffffffull; +@@ -539,7 +539,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + (ch >= 'A' && ch <= 'F') || + (ch >= 'a' && ch <= 'f')); + } else { +- pp->parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); + } + if (ch == 'u' || ch == 'U') { + if (len < MaxTokenLength) +@@ -557,7 +557,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + #ifdef AMD_EXTENSIONS + nextCh = getch(); + if ((nextCh == 's' || nextCh == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; +@@ -570,7 +570,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + isInt64 = true; + #ifdef AMD_EXTENSIONS + } else if ((ch == 's' || ch == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +@@ -579,21 +579,21 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + ungetch(); + ppToken->name[len] = '\0'; + +- if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (pp->ifdepth == 0) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "64-bit hexadecimal literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int64_Extensions, Int64_Extensions, "64-bit hexadecimal literal"); + } + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else if (isInt16) { + if (pp->ifdepth == 0) { +- if (pp->parseContext.intermediate.getSource() == EShSourceGlsl) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ if (pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "16-bit hexadecimal literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int16_Extensions, Int16_Extensions, "16-bit hexadecimal literal"); + } + } +@@ -601,7 +601,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16; + } else { + if (ival > 0xffffffffu && !AlreadyComplained) +- pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); + ppToken->ival = (int)ival; + return isUnsigned ? PpAtomConstUint : PpAtomConstInt; + } +@@ -620,7 +620,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + else if (! AlreadyComplained) { +- pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + AlreadyComplained = 1; + } + if (ival <= 0x1fffffffffffffffull) { +@@ -638,7 +638,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + else if (! AlreadyComplained) { +- pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + AlreadyComplained = 1; + } + ch = getch(); +@@ -649,7 +649,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + + // wasn't a float, so must be octal... + if (nonOctal) +- pp->parseContext.ppError(ppToken->loc, "octal literal digit too large", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "octal literal digit too large", "", ""); + + if (ch == 'u' || ch == 'U') { + if (len < MaxTokenLength) +@@ -667,7 +667,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + #ifdef AMD_EXTENSIONS + nextCh = getch(); + if ((nextCh == 's' || nextCh == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; +@@ -680,7 +680,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + isInt64 = true; + #ifdef AMD_EXTENSIONS + } else if ((ch == 's' || ch == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +@@ -693,23 +693,23 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + octalOverflow = true; + + if (octalOverflow) +- pp->parseContext.ppError(ppToken->loc, "octal literal too big", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "octal literal too big", "", ""); + +- if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (pp->ifdepth == 0) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "64-bit octal literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int64_Extensions, Int64_Extensions, "64-bit octal literal"); + } + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else if (isInt16) { + if (pp->ifdepth == 0) { +- if (pp->parseContext.intermediate.getSource() == EShSourceGlsl) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ if (pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "16-bit octal literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int16_Extensions, Int16_Extensions, "16-bit octal literal"); + } + } +@@ -729,7 +729,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + else if (! AlreadyComplained) { +- pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + AlreadyComplained = 1; + } + ch = getch(); +@@ -758,7 +758,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + #ifdef AMD_EXTENSIONS + nextCh = getch(); + if ((nextCh == 's' || nextCh == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)nextCh; + isInt16 = true; +@@ -771,7 +771,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + isInt64 = true; + #ifdef AMD_EXTENSIONS + } else if ((ch == 's' || ch == 'S') && +- pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (len < MaxTokenLength) + ppToken->name[len++] = (char)ch; + isInt16 = true; +@@ -797,27 +797,27 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + else + overflow = (ival > oneTenthMaxInt || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt)); + if (overflow) { +- pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); ++ pp->_parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); + ival = 0xFFFFFFFFFFFFFFFFull; + break; + } else + ival = ival * 10 + ch; + } + +- if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { ++ if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + if (pp->ifdepth == 0) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "64-bit literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int64_Extensions, Int64_Extensions, "64-bit literal"); + } + ppToken->i64val = ival; + return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; + } else if (isInt16) { +- if (pp->ifdepth == 0 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { +- pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, ++ if (pp->ifdepth == 0 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { ++ pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, + "16-bit literal"); +- pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, ++ pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + Num_Int16_Extensions, Int16_Extensions, "16-bit literal"); + } + ppToken->ival = (int)ival; +@@ -970,14 +970,14 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + do { + while (ch != '*') { + if (ch == EndOfInput) { +- pp->parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); ++ pp->_parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); + return ch; + } + ch = getch(); + } + ch = getch(); + if (ch == EndOfInput) { +- pp->parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); ++ pp->_parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); + return ch; + } + } while (ch != '/'); +@@ -1009,7 +1009,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) + ppToken->name[len] = '\0'; + if (ch != '"') { + ungetch(); +- pp->parseContext.ppError(ppToken->loc, "End of line in string", "string", ""); ++ pp->_parseContext.ppError(ppToken->loc, "End of line in string", "string", ""); + } + return PpAtomConstString; + case ':': +@@ -1051,7 +1051,7 @@ int TPpContext::tokenize(TPpToken& ppToken) + } + continue; + } else { +- parseContext.ppError(ppToken.loc, "preprocessor directive cannot be preceded by another token", "#", ""); ++ _parseContext.ppError(ppToken.loc, "preprocessor directive cannot be preceded by another token", "#", ""); + return EndOfInput; + } + } +@@ -1079,14 +1079,14 @@ int TPpContext::tokenize(TPpToken& ppToken) + continue; + break; + case PpAtomConstString: +- if (ifdepth == 0 && parseContext.intermediate.getSource() != EShSourceHlsl) { ++ if (ifdepth == 0 && _parseContext.intermediate.getSource() != EShSourceHlsl) { + // HLSL allows string literals. +- parseContext.ppError(ppToken.loc, "string literals not supported", "\"\"", ""); ++ _parseContext.ppError(ppToken.loc, "string literals not supported", "\"\"", ""); + continue; + } + break; + case '\'': +- parseContext.ppError(ppToken.loc, "character literals not supported", "\'", ""); ++ _parseContext.ppError(ppToken.loc, "character literals not supported", "\'", ""); + continue; + default: + strcpy(ppToken.name, atomStrings.getString(token)); +@@ -1106,7 +1106,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + { + // starting with ## is illegal, skip to next token + if (token == PpAtomPaste) { +- parseContext.ppError(ppToken.loc, "unexpected location", "##", ""); ++ _parseContext.ppError(ppToken.loc, "unexpected location", "##", ""); + return scanToken(&ppToken); + } + +@@ -1122,7 +1122,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + + // This covers end of macro expansion + if (endOfReplacementList()) { +- parseContext.ppError(ppToken.loc, "unexpected location; end of replacement list", "##", ""); ++ _parseContext.ppError(ppToken.loc, "unexpected location; end of replacement list", "##", ""); + break; + } + +@@ -1131,7 +1131,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + + // This covers end of argument expansion + if (token == tMarkerInput::marker) { +- parseContext.ppError(ppToken.loc, "unexpected location; end of argument", "##", ""); ++ _parseContext.ppError(ppToken.loc, "unexpected location; end of argument", "##", ""); + break; + } + +@@ -1162,13 +1162,13 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + strcpy(pastedPpToken.name, atomStrings.getString(token)); + break; + default: +- parseContext.ppError(ppToken.loc, "not supported for these tokens", "##", ""); ++ _parseContext.ppError(ppToken.loc, "not supported for these tokens", "##", ""); + return resultToken; + } + + // combine the tokens + if (strlen(ppToken.name) + strlen(pastedPpToken.name) > MaxTokenLength) { +- parseContext.ppError(ppToken.loc, "combined tokens are too long", "##", ""); ++ _parseContext.ppError(ppToken.loc, "combined tokens are too long", "##", ""); + return resultToken; + } + strncat(ppToken.name, pastedPpToken.name, MaxTokenLength - strlen(ppToken.name)); +@@ -1179,7 +1179,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + if (newToken > 0) + resultToken = newToken; + else +- parseContext.ppError(ppToken.loc, "combined token is invalid", "##", ""); ++ _parseContext.ppError(ppToken.loc, "combined token is invalid", "##", ""); + } + } + +@@ -1190,7 +1190,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) + void TPpContext::missingEndifCheck() + { + if (ifdepth > 0) +- parseContext.ppError(parseContext.getCurrentLoc(), "missing #endif", "", ""); ++ _parseContext.ppError(_parseContext.getCurrentLoc(), "missing #endif", "", ""); + } + + } // end namespace glslang +diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp +index 7dc2722ce1..475d0aad3b 100755 +--- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp ++++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp +@@ -195,7 +195,7 @@ void TPpContext::TokenStream::putToken(int atom, TPpToken* ppToken) + + // Read the next token from a token stream. + // (Not the source stream, but a stream used to hold a tokenized macro). +-int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken *ppToken) ++int TPpContext::TokenStream::getToken(TParseContextBase& _parseContext, TPpToken *ppToken) + { + // get the atom + int atom = getSubtoken(); +@@ -204,7 +204,7 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken + + // init the token + ppToken->clear(); +- ppToken->loc = parseContext.getCurrentLoc(); ++ ppToken->loc = _parseContext.getCurrentLoc(); + + // get the backing name string + if (SaveName(atom)) { +@@ -216,7 +216,7 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken + len++; + ch = getSubtoken(); + } else { +- parseContext.error(ppToken->loc, "token too long", "", ""); ++ _parseContext.error(ppToken->loc, "token too long", "", ""); + break; + } + } +@@ -227,8 +227,8 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken + if (atom == '#') { + if (current < data.size()) { + if (getSubtoken() == '#') { +- parseContext.requireProfile(ppToken->loc, ~EEsProfile, "token pasting (##)"); +- parseContext.profileRequires(ppToken->loc, ~EEsProfile, 130, 0, "token pasting (##)"); ++ _parseContext.requireProfile(ppToken->loc, ~EEsProfile, "token pasting (##)"); ++ _parseContext.profileRequires(ppToken->loc, ~EEsProfile, 130, 0, "token pasting (##)"); + atom = PpAtomPaste; + } else + ungetSubtoken(); +diff --git a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp +index 870840c56e..49c31492a1 100644 +--- a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp ++++ b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp +@@ -34,6 +34,7 @@ + + #include "../osinclude.h" + ++#undef STRICT + #define STRICT + #define VC_EXTRALEAN 1 + #include +diff --git a/deps/glslang/glslang/hlsl/hlslGrammar.cpp b/deps/glslang/glslang/hlsl/hlslGrammar.cpp +index cb05877917..aa05465abc 100755 +--- a/deps/glslang/glslang/hlsl/hlslGrammar.cpp ++++ b/deps/glslang/glslang/hlsl/hlslGrammar.cpp +@@ -67,12 +67,12 @@ bool HlslGrammar::parse() + + void HlslGrammar::expected(const char* syntax) + { +- parseContext.error(token.loc, "Expected", syntax, ""); ++ _parseContext.error(token.loc, "Expected", syntax, ""); + } + + void HlslGrammar::unimplemented(const char* error) + { +- parseContext.error(token.loc, "Unimplemented", error, ""); ++ _parseContext.error(token.loc, "Unimplemented", error, ""); + } + + // IDENTIFIER +@@ -195,7 +195,7 @@ bool HlslGrammar::acceptSamplerState() + if (! acceptTokenClass(EHTokLeftBrace)) + return true; + +- parseContext.warn(token.loc, "unimplemented", "immediate sampler state", ""); ++ _parseContext.warn(token.loc, "unimplemented", "immediate sampler state", ""); + + do { + // read state name +@@ -337,7 +337,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + expected("namespace name"); + return false; + } +- parseContext.pushNamespace(*namespaceToken.string); ++ _parseContext.pushNamespace(*namespaceToken.string); + if (!acceptTokenClass(EHTokLeftBrace)) { + expected("{"); + return false; +@@ -350,7 +350,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + expected("}"); + return false; + } +- parseContext.popNamespace(); ++ _parseContext.popNamespace(); + return true; + } + +@@ -391,16 +391,16 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + TIntermAggregate* initializers = nullptr; + while (acceptIdentifier(idToken)) { + TString *fullName = idToken.string; +- if (parseContext.symbolTable.atGlobalLevel()) +- parseContext.getFullNamespaceName(fullName); ++ if (_parseContext.symbolTable.atGlobalLevel()) ++ _parseContext.getFullNamespaceName(fullName); + if (peekTokenClass(EHTokLeftParen)) { + // looks like function parameters + + // merge in the attributes into the return type +- parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true); ++ _parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true); + + // Potentially rename shader entry point function. No-op most of the time. +- parseContext.renameShaderFunction(fullName); ++ _parseContext.renameShaderFunction(fullName); + + // function_parameters + declarator.function = new TFunction(fullName, declaredType); +@@ -416,24 +416,24 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + declarator.loc = token.loc; + if (peekTokenClass(EHTokLeftBrace)) { + if (declarator_list) +- parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", ""); ++ _parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", ""); + if (typedefDecl) +- parseContext.error(idToken.loc, "function body can't be in a typedef", "{", ""); ++ _parseContext.error(idToken.loc, "function body can't be in a typedef", "{", ""); + return acceptFunctionDefinition(declarator, nodeList, nullptr); + } else { + if (typedefDecl) +- parseContext.error(idToken.loc, "function typedefs not implemented", "{", ""); +- parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true); ++ _parseContext.error(idToken.loc, "function typedefs not implemented", "{", ""); ++ _parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true); + } + } else { + // A variable declaration. + + // merge in the attributes, the first time around, into the shared type + if (! declarator_list) +- parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType); ++ _parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType); + + // Fix the storage qualifier if it's a global. +- if (declaredType.getQualifier().storage == EvqTemporary && parseContext.symbolTable.atGlobalLevel()) ++ if (declaredType.getQualifier().storage == EvqTemporary && _parseContext.symbolTable.atGlobalLevel()) + declaredType.getQualifier().storage = EvqUniform; + + // recognize array_specifier +@@ -464,7 +464,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + TIntermTyped* expressionNode = nullptr; + if (acceptTokenClass(EHTokAssign)) { + if (typedefDecl) +- parseContext.error(idToken.loc, "can't have an initializer", "typedef", ""); ++ _parseContext.error(idToken.loc, "can't have an initializer", "typedef", ""); + if (! acceptAssignmentExpression(expressionNode)) { + expected("initializer"); + return false; +@@ -473,24 +473,24 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) + + // TODO: things scoped within an annotation need their own name space; + // TODO: strings are not yet handled. +- if (variableType.getBasicType() != EbtString && parseContext.getAnnotationNestingLevel() == 0) { ++ if (variableType.getBasicType() != EbtString && _parseContext.getAnnotationNestingLevel() == 0) { + if (typedefDecl) +- parseContext.declareTypedef(idToken.loc, *fullName, variableType); ++ _parseContext.declareTypedef(idToken.loc, *fullName, variableType); + else if (variableType.getBasicType() == EbtBlock) { + if (expressionNode) +- parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", ""); +- parseContext.declareBlock(idToken.loc, variableType, fullName); +- parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName); ++ _parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", ""); ++ _parseContext.declareBlock(idToken.loc, variableType, fullName); ++ _parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName); + } else { + if (variableType.getQualifier().storage == EvqUniform && ! variableType.containsOpaque()) { + // this isn't really an individual variable, but a member of the $Global buffer +- parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName); ++ _parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName); + } else { + // Declare the variable and add any initializer code to the AST. + // The top-level node is always made into an aggregate, as that's + // historically how the AST has been. + initializers = intermediate.growAggregate(initializers, +- parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode), ++ _parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode), + idToken.loc); + } + } +@@ -544,7 +544,7 @@ bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node) + return false; + + if (attributes.size() > 0) +- parseContext.warn(token.loc, "attributes don't apply to control declaration", "", ""); ++ _parseContext.warn(token.loc, "attributes don't apply to control declaration", "", ""); + + // filter out type casts + if (peekTokenClass(EHTokLeftParen)) { +@@ -572,7 +572,7 @@ bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node) + return false; + } + +- node = parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode); ++ node = _parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode); + + return true; + } +@@ -608,16 +608,16 @@ bool HlslGrammar::acceptFullySpecifiedType(TType& type, TIntermNode*& nodeList, + + if (type.getBasicType() == EbtBlock) { + // the type was a block, which set some parts of the qualifier +- parseContext.mergeQualifiers(type.getQualifier(), qualifier); ++ _parseContext.mergeQualifiers(type.getQualifier(), qualifier); + + // merge in the attributes +- parseContext.transferTypeAttributes(token.loc, attributes, type); ++ _parseContext.transferTypeAttributes(token.loc, attributes, type); + + // further, it can create an anonymous instance of the block + // (cbuffer and tbuffer don't consume the next identifier, and + // should set forbidDeclarators) + if (forbidDeclarators || peek() != EHTokIdentifier) +- parseContext.declareBlock(loc, type); ++ _parseContext.declareBlock(loc, type); + } else { + // Some qualifiers are set when parsing the type. Merge those with + // whatever comes from acceptQualifier. +@@ -651,7 +651,7 @@ bool HlslGrammar::acceptQualifier(TQualifier& qualifier) + do { + switch (peek()) { + case EHTokStatic: +- qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; ++ qualifier.storage = _parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; + break; + case EHTokExtern: + // TODO: no meaning in glslang? +@@ -719,27 +719,27 @@ bool HlslGrammar::acceptQualifier(TQualifier& qualifier) + // for output variables. + case EHTokPoint: + qualifier.storage = EvqIn; +- if (!parseContext.handleInputGeometry(token.loc, ElgPoints)) ++ if (!_parseContext.handleInputGeometry(token.loc, ElgPoints)) + return false; + break; + case EHTokLine: + qualifier.storage = EvqIn; +- if (!parseContext.handleInputGeometry(token.loc, ElgLines)) ++ if (!_parseContext.handleInputGeometry(token.loc, ElgLines)) + return false; + break; + case EHTokTriangle: + qualifier.storage = EvqIn; +- if (!parseContext.handleInputGeometry(token.loc, ElgTriangles)) ++ if (!_parseContext.handleInputGeometry(token.loc, ElgTriangles)) + return false; + break; + case EHTokLineAdj: + qualifier.storage = EvqIn; +- if (!parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency)) ++ if (!_parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency)) + return false; + break; + case EHTokTriangleAdj: + qualifier.storage = EvqIn; +- if (!parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency)) ++ if (!_parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency)) + return false; + break; + +@@ -781,9 +781,9 @@ bool HlslGrammar::acceptLayoutQualifierList(TQualifier& qualifier) + expected("expression"); + return false; + } +- parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr); ++ _parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr); + } else +- parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string); ++ _parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string); + + // COMMA + if (! acceptTokenClass(EHTokComma)) +@@ -1076,7 +1076,7 @@ bool HlslGrammar::acceptAnnotations(TQualifier&) + return false; + + // note that we are nesting a name space +- parseContext.nestAnnotations(); ++ _parseContext.nestAnnotations(); + + // declaration SEMI_COLON ... declaration SEMICOLON RIGHT_ANGLE + do { +@@ -1095,7 +1095,7 @@ bool HlslGrammar::acceptAnnotations(TQualifier&) + } + } while (true); + +- parseContext.unnestAnnotations(); ++ _parseContext.unnestAnnotations(); + return true; + } + +@@ -1154,7 +1154,7 @@ bool HlslGrammar::acceptSubpassInputType(TType& type) + sampler.setSubpass(subpassBasicType, multisample); + + // Remember the declared return type. Function returns false on error. +- if (!parseContext.setTextureReturnType(sampler, subpassType, token.loc)) ++ if (!_parseContext.setTextureReturnType(sampler, subpassType, token.loc)) + return false; + + type.shallowCopy(TType(sampler, EvqUniform)); +@@ -1327,7 +1327,7 @@ bool HlslGrammar::acceptTextureType(TType& type) + + // Buffer, RWBuffer and RWTexture (images) require a TLayoutFormat. We handle only a limit set. + if (image || dim == EsdBuffer) +- format = parseContext.getLayoutFromTxType(token.loc, txType); ++ format = _parseContext.getLayoutFromTxType(token.loc, txType); + + const TBasicType txBasicType = txType.isStruct() ? (*txType.getStruct())[0].type->getBasicType() + : txType.getBasicType(); +@@ -1345,7 +1345,7 @@ bool HlslGrammar::acceptTextureType(TType& type) + } + + // Remember the declared return type. Function returns false on error. +- if (!parseContext.setTextureReturnType(sampler, txType, token.loc)) ++ if (!_parseContext.setTextureReturnType(sampler, txType, token.loc)) + return false; + + // Force uncombined, if necessary +@@ -1369,7 +1369,7 @@ bool HlslGrammar::acceptType(TType& type) + bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) + { + // Basic types for min* types, use native halfs if the option allows them. +- bool enable16BitTypes = parseContext.hlslEnable16BitTypes(); ++ bool enable16BitTypes = _parseContext.hlslEnable16BitTypes(); + + const TBasicType min16float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat; + const TBasicType min10float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat; +@@ -1385,7 +1385,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) + if (identifierString != nullptr) { + TString name = identifierString; + // if it's an identifier, it's not a type +- if (parseContext.symbolTable.find(name) != nullptr) ++ if (_parseContext.symbolTable.find(name) != nullptr) + return false; + } + } +@@ -1424,7 +1424,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) + if (! acceptStreamOutTemplateType(type, geometry)) + return false; + +- if (! parseContext.handleOutputGeometry(token.loc, geometry)) ++ if (! _parseContext.handleOutputGeometry(token.loc, geometry)) + return false; + + return true; +@@ -1499,7 +1499,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) + // An identifier could be for a user-defined type. + // Note we cache the symbol table lookup, to save for a later rule + // when this is not a type. +- if (parseContext.lookupUserType(*token.string, type) != nullptr) { ++ if (_parseContext.lookupUserType(*token.string, type) != nullptr) { + advanceToken(); + return true; + } else +@@ -2006,7 +2006,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) + advanceToken(); + + if ((isUnorm || isSnorm) && !type.isFloatingDomain()) { +- parseContext.error(token.loc, "unorm and snorm only valid in floating point domain", "", ""); ++ _parseContext.error(token.loc, "unorm and snorm only valid in floating point domain", "", ""); + return false; + } + +@@ -2068,7 +2068,7 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) + // LEFT_BRACE, or + // struct_type IDENTIFIER + if (! acceptTokenClass(EHTokLeftBrace)) { +- if (structName.size() > 0 && !postDeclsFound && parseContext.lookupUserType(structName, type) != nullptr) { ++ if (structName.size() > 0 && !postDeclsFound && _parseContext.lookupUserType(structName, type) != nullptr) { + // struct_type IDENTIFIER + return true; + } else { +@@ -2083,9 +2083,9 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) + // Save each member function so they can be processed after we have a fully formed 'this'. + TVector functionDeclarators; + +- parseContext.pushNamespace(structName); ++ _parseContext.pushNamespace(structName); + bool acceptedList = acceptStructDeclarationList(typeList, nodeList, functionDeclarators); +- parseContext.popNamespace(); ++ _parseContext.popNamespace(); + + if (! acceptedList) { + expected("struct member declarations"); +@@ -2107,7 +2107,7 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) + new(&type) TType(typeList, structName, postDeclQualifier); // sets EbtBlock + } + +- parseContext.declareStruct(token.loc, structName, type); ++ _parseContext.declareStruct(token.loc, structName, type); + + // For member functions: now that we know the type of 'this', go back and + // - add their implicit argument with 'this' (not to the mangling, just the argument list) +@@ -2120,8 +2120,8 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) + + // All member functions get parsed inside the class/struct namespace and with the + // class/struct members in a symbol-table level. +- parseContext.pushNamespace(structName); +- parseContext.pushThisScope(type, functionDeclarators); ++ _parseContext.pushNamespace(structName); ++ _parseContext.pushThisScope(type, functionDeclarators); + bool deferredSuccess = true; + for (int b = 0; b < (int)functionDeclarators.size() && deferredSuccess; ++b) { + // parse body +@@ -2130,8 +2130,8 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) + deferredSuccess = false; + popTokenStream(); + } +- parseContext.popThisScope(); +- parseContext.popNamespace(); ++ _parseContext.popThisScope(); ++ _parseContext.popNamespace(); + + return deferredSuccess; + } +@@ -2172,7 +2172,7 @@ bool HlslGrammar::acceptConstantBufferType(TType& type) + + return true; + } else { +- parseContext.error(token.loc, "non-structure type in ConstantBuffer", "", ""); ++ _parseContext.error(token.loc, "non-structure type in ConstantBuffer", "", ""); + return false; + } + } +@@ -2307,7 +2307,7 @@ bool HlslGrammar::acceptStructBufferType(TType& type) + + // We may have created an equivalent type before, in which case we should use its + // deep structure. +- parseContext.shareStructBufferType(blockType); ++ _parseContext.shareStructBufferType(blockType); + + type.shallowCopy(blockType); + +@@ -2353,7 +2353,7 @@ bool HlslGrammar::acceptStructDeclarationList(TTypeList*& typeList, TIntermNode* + } + + // merge in the attributes +- parseContext.transferTypeAttributes(token.loc, attributes, memberType); ++ _parseContext.transferTypeAttributes(token.loc, attributes, memberType); + + // struct_declarator COMMA struct_declarator ... + bool functionDefinitionAccepted = false; +@@ -2392,7 +2392,7 @@ bool HlslGrammar::acceptStructDeclarationList(TTypeList*& typeList, TIntermNode* + + // EQUAL assignment_expression + if (acceptTokenClass(EHTokAssign)) { +- parseContext.warn(idToken.loc, "struct-member initializers ignored", "typedef", ""); ++ _parseContext.warn(idToken.loc, "struct-member initializers ignored", "typedef", ""); + TIntermTyped* expressionNode = nullptr; + if (! acceptAssignmentExpression(expressionNode)) { + expected("initializer"); +@@ -2436,7 +2436,7 @@ bool HlslGrammar::acceptMemberFunctionDefinition(TIntermNode*& nodeList, const T + bool accepted = false; + + TString* functionName = &memberName; +- parseContext.getFullNamespaceName(functionName); ++ _parseContext.getFullNamespaceName(functionName); + declarator.function = new TFunction(functionName, type); + if (type.getQualifier().storage == EvqTemporary) + declarator.function->setImplicitThis(); +@@ -2509,15 +2509,15 @@ bool HlslGrammar::acceptDefaultParameterDeclaration(const TType& type, TIntermTy + + // For initializer lists, we have to const-fold into a constructor for the type, so build + // that. +- TFunction* constructor = parseContext.makeConstructorCall(token.loc, type); ++ TFunction* constructor = _parseContext.makeConstructorCall(token.loc, type); + if (constructor == nullptr) // cannot construct + return false; + + TIntermTyped* arguments = nullptr; + for (int i = 0; i < int(node->getAsAggregate()->getSequence().size()); i++) +- parseContext.handleFunctionArgument(constructor, arguments, node->getAsAggregate()->getSequence()[i]->getAsTyped()); ++ _parseContext.handleFunctionArgument(constructor, arguments, node->getAsAggregate()->getSequence()[i]->getAsTyped()); + +- node = parseContext.handleFunctionCall(token.loc, constructor, node); ++ node = _parseContext.handleFunctionCall(token.loc, constructor, node); + } + + if (node == nullptr) +@@ -2535,7 +2535,7 @@ bool HlslGrammar::acceptDefaultParameterDeclaration(const TType& type, TIntermTy + if (node != nullptr && origNode != node) + return true; + +- parseContext.error(token.loc, "invalid default parameter value", "", ""); ++ _parseContext.error(token.loc, "invalid default parameter value", "", ""); + + return false; + } +@@ -2559,7 +2559,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) + return false; + + // merge in the attributes +- parseContext.transferTypeAttributes(token.loc, attributes, *type); ++ _parseContext.transferTypeAttributes(token.loc, attributes, *type); + + // identifier + HlslToken idToken; +@@ -2570,7 +2570,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) + acceptArraySpecifier(arraySizes); + if (arraySizes) { + if (arraySizes->hasUnsized()) { +- parseContext.error(token.loc, "function parameter requires array size", "[]", ""); ++ _parseContext.error(token.loc, "function parameter requires array size", "[]", ""); + return false; + } + +@@ -2584,11 +2584,11 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) + if (!acceptDefaultParameterDeclaration(*type, defaultValue)) + return false; + +- parseContext.paramFix(*type); ++ _parseContext.paramFix(*type); + + // If any prior parameters have default values, all the parameters after that must as well. + if (defaultValue == nullptr && function.getDefaultParamCount() > 0) { +- parseContext.error(idToken.loc, "invalid parameter after default value parameters", idToken.string->c_str(), ""); ++ _parseContext.error(idToken.loc, "invalid parameter after default value parameters", idToken.string->c_str(), ""); + return false; + } + +@@ -2607,7 +2607,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) + bool HlslGrammar::acceptFunctionDefinition(TFunctionDeclarator& declarator, TIntermNode*& nodeList, + TVector* deferredTokens) + { +- parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, false /* not prototype */); ++ _parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, false /* not prototype */); + + if (deferredTokens) + return captureBlockTokens(*deferredTokens); +@@ -2621,7 +2621,7 @@ bool HlslGrammar::acceptFunctionBody(TFunctionDeclarator& declarator, TIntermNod + TIntermNode* entryPointNode = nullptr; + + // This does a pushScope() +- TIntermNode* functionNode = parseContext.handleFunctionDefinition(declarator.loc, *declarator.function, ++ TIntermNode* functionNode = _parseContext.handleFunctionDefinition(declarator.loc, *declarator.function, + declarator.attributes, entryPointNode); + + // compound_statement +@@ -2630,7 +2630,7 @@ bool HlslGrammar::acceptFunctionBody(TFunctionDeclarator& declarator, TIntermNod + return false; + + // this does a popScope() +- parseContext.handleFunctionBody(declarator.loc, *declarator.function, functionBody, functionNode); ++ _parseContext.handleFunctionBody(declarator.loc, *declarator.function, functionBody, functionNode); + + // Hook up the 1 or 2 function definitions. + nodeList = intermediate.growAggregate(nodeList, functionNode); +@@ -2817,11 +2817,11 @@ bool HlslGrammar::acceptAssignmentExpression(TIntermTyped*& node) + return false; + } + +- node = parseContext.handleAssign(loc, assignOp, node, rightNode); +- node = parseContext.handleLvalue(loc, "assign", node); ++ node = _parseContext.handleAssign(loc, assignOp, node, rightNode); ++ node = _parseContext.handleLvalue(loc, "assign", node); + + if (node == nullptr) { +- parseContext.error(loc, "could not create assignment", "", ""); ++ _parseContext.error(loc, "could not create assignment", "", ""); + return false; + } + +@@ -2848,11 +2848,11 @@ bool HlslGrammar::acceptConditionalExpression(TIntermTyped*& node) + if (! acceptTokenClass(EHTokQuestion)) + return true; + +- node = parseContext.convertConditionalExpression(token.loc, node, false); ++ node = _parseContext.convertConditionalExpression(token.loc, node, false); + if (node == nullptr) + return false; + +- ++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors ++ ++_parseContext.controlFlowNestingLevel; // this only needs to work right if no errors + + TIntermTyped* trueNode = nullptr; + if (! acceptExpression(trueNode)) { +@@ -2872,7 +2872,7 @@ bool HlslGrammar::acceptConditionalExpression(TIntermTyped*& node) + return false; + } + +- --parseContext.controlFlowNestingLevel; ++ --_parseContext.controlFlowNestingLevel; + + node = intermediate.addSelection(node, trueNode, falseNode, loc); + +@@ -2917,7 +2917,7 @@ bool HlslGrammar::acceptBinaryExpression(TIntermTyped*& node, PrecedenceLevel pr + + node = intermediate.addBinaryMath(op, node, rightNode, loc); + if (node == nullptr) { +- parseContext.error(loc, "Could not perform requested binary operation", "", ""); ++ _parseContext.error(loc, "Could not perform requested binary operation", "", ""); + return false; + } + } while (true); +@@ -2953,14 +2953,14 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) + return false; + + // Hook it up like a constructor +- TFunction* constructorFunction = parseContext.makeConstructorCall(loc, castType); ++ TFunction* constructorFunction = _parseContext.makeConstructorCall(loc, castType); + if (constructorFunction == nullptr) { + expected("type that can be constructed"); + return false; + } + TIntermTyped* arguments = nullptr; +- parseContext.handleFunctionArgument(constructorFunction, arguments, node); +- node = parseContext.handleFunctionCall(loc, constructorFunction, arguments); ++ _parseContext.handleFunctionArgument(constructorFunction, arguments, node); ++ node = _parseContext.handleFunctionCall(loc, constructorFunction, arguments); + + return node != nullptr; + } else { +@@ -2972,7 +2972,7 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) + // Note, there are no array constructors like + // (float[2](...)) + if (arraySizes != nullptr) +- parseContext.error(loc, "parenthesized array constructor not allowed", "([]())", "", ""); ++ _parseContext.error(loc, "parenthesized array constructor not allowed", "([]())", "", ""); + } + } else { + // This isn't a type cast, but it still started "(", so if it is a +@@ -3004,7 +3004,7 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) + + // These unary ops require lvalues + if (unaryOp == EOpPreIncrement || unaryOp == EOpPreDecrement) +- node = parseContext.handleLvalue(loc, "unary operator", node); ++ node = _parseContext.handleLvalue(loc, "unary operator", node); + + return node != nullptr; + } +@@ -3052,7 +3052,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) + while (acceptTokenClass(EHTokColonColon)) { + // user-type or namespace name + fullName = NewPoolTString(fullName->c_str()); +- fullName->append(parseContext.scopeMangler); ++ fullName->append(_parseContext.scopeMangler); + if (acceptIdentifier(idToken)) + fullName->append(*idToken.string); + else { +@@ -3061,7 +3061,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) + } + } + if (! peekTokenClass(EHTokLeftParen)) { +- node = parseContext.handleVariable(idToken.loc, fullName); ++ node = _parseContext.handleVariable(idToken.loc, fullName); + if (node == nullptr) + return false; + } else if (acceptFunctionCall(idToken.loc, *fullName, node, nullptr)) { +@@ -3116,7 +3116,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) + return false; + } + } else +- node = parseContext.handleDotDereference(field.loc, node, *field.string); ++ node = _parseContext.handleDotDereference(field.loc, node, *field.string); + + break; + } +@@ -3130,7 +3130,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) + return false; + } + advanceToken(); +- node = parseContext.handleBracketDereference(indexNode->getLoc(), node, indexNode); ++ node = _parseContext.handleBracketDereference(indexNode->getLoc(), node, indexNode); + if (node == nullptr) + return false; + break; +@@ -3141,7 +3141,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) + case EOpPostDecrement: + // DEC_OP + node = intermediate.addUnaryMath(postOp, node, loc); +- node = parseContext.handleLvalue(loc, "unary operator", node); ++ node = _parseContext.handleLvalue(loc, "unary operator", node); + break; + default: + assert(0); +@@ -3158,7 +3158,7 @@ bool HlslGrammar::acceptConstructor(TIntermTyped*& node) + // type + TType type; + if (acceptType(type)) { +- TFunction* constructorFunction = parseContext.makeConstructorCall(token.loc, type); ++ TFunction* constructorFunction = _parseContext.makeConstructorCall(token.loc, type); + if (constructorFunction == nullptr) + return false; + +@@ -3172,7 +3172,7 @@ bool HlslGrammar::acceptConstructor(TIntermTyped*& node) + } + + // hook it up +- node = parseContext.handleFunctionCall(arguments->getLoc(), constructorFunction, arguments); ++ node = _parseContext.handleFunctionCall(arguments->getLoc(), constructorFunction, arguments); + + return node != nullptr; + } +@@ -3191,7 +3191,7 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte + TString* functionName = nullptr; + if (baseObject == nullptr) { + functionName = &name; +- } else if (parseContext.isBuiltInMethod(loc, baseObject, name)) { ++ } else if (_parseContext.isBuiltInMethod(loc, baseObject, name)) { + // Built-in methods are not in the symbol table as methods, but as global functions + // taking an explicit 'this' as the first argument. + functionName = NewPoolTString(BUILTIN_PREFIX); +@@ -3203,7 +3203,7 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte + } + functionName = NewPoolTString(""); + functionName->append(baseObject->getType().getTypeName()); +- parseContext.addScopeMangler(*functionName); ++ _parseContext.addScopeMangler(*functionName); + functionName->append(name); + } + +@@ -3214,13 +3214,13 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte + TIntermTyped* arguments = nullptr; + if (baseObject != nullptr) { + // Non-static member functions have an implicit first argument of the base object. +- parseContext.handleFunctionArgument(function, arguments, baseObject); ++ _parseContext.handleFunctionArgument(function, arguments, baseObject); + } + if (! acceptArguments(function, arguments)) + return false; + + // call +- node = parseContext.handleFunctionCall(loc, function, arguments); ++ node = _parseContext.handleFunctionCall(loc, function, arguments); + + return node != nullptr; + } +@@ -3249,7 +3249,7 @@ bool HlslGrammar::acceptArguments(TFunction* function, TIntermTyped*& arguments) + return false; + + // hook it up +- parseContext.handleFunctionArgument(function, arguments, arg); ++ _parseContext.handleFunctionArgument(function, arguments, arg); + + // COMMA + if (! acceptTokenClass(EHTokComma)) +@@ -3348,7 +3348,7 @@ bool HlslGrammar::acceptCompoundStatement(TIntermNode*& retStatement) + if (branch != nullptr && (branch->getFlowOp() == EOpCase || + branch->getFlowOp() == EOpDefault)) { + // hook up individual subsequences within a switch statement +- parseContext.wrapupSwitchSubsequence(compoundStatement, statement); ++ _parseContext.wrapupSwitchSubsequence(compoundStatement, statement); + compoundStatement = nullptr; + } else { + // hook it up to the growing compound statement +@@ -3366,18 +3366,18 @@ bool HlslGrammar::acceptCompoundStatement(TIntermNode*& retStatement) + + bool HlslGrammar::acceptScopedStatement(TIntermNode*& statement) + { +- parseContext.pushScope(); ++ _parseContext.pushScope(); + bool result = acceptStatement(statement); +- parseContext.popScope(); ++ _parseContext.popScope(); + + return result; + } + + bool HlslGrammar::acceptScopedCompoundStatement(TIntermNode*& statement) + { +- parseContext.pushScope(); ++ _parseContext.pushScope(); + bool result = acceptCompoundStatement(statement); +- parseContext.popScope(); ++ _parseContext.popScope(); + + return result; + } +@@ -3545,9 +3545,9 @@ void HlslGrammar::acceptAttributes(TAttributes& attributes) + + // Add any values we found into the attribute map. + if (attributeToken.string != nullptr) { +- TAttributeType attributeType = parseContext.attributeFromName(nameSpace, *attributeToken.string); ++ TAttributeType attributeType = _parseContext.attributeFromName(nameSpace, *attributeToken.string); + if (attributeType == EatNone) +- parseContext.warn(attributeToken.loc, "unrecognized attribute", attributeToken.string->c_str(), ""); ++ _parseContext.warn(attributeToken.loc, "unrecognized attribute", attributeToken.string->c_str(), ""); + else { + TAttributeArgs attributeArgs = { attributeType, expressions }; + attributes.push_back(attributeArgs); +@@ -3570,20 +3570,20 @@ bool HlslGrammar::acceptSelectionStatement(TIntermNode*& statement, const TAttri + + // so that something declared in the condition is scoped to the lifetimes + // of the then-else statements +- parseContext.pushScope(); ++ _parseContext.pushScope(); + + // LEFT_PAREN expression RIGHT_PAREN + TIntermTyped* condition; + if (! acceptParenExpression(condition)) + return false; +- condition = parseContext.convertConditionalExpression(loc, condition); ++ condition = _parseContext.convertConditionalExpression(loc, condition); + if (condition == nullptr) + return false; + + // create the child statements + TIntermNodePair thenElse = { nullptr, nullptr }; + +- ++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors ++ ++_parseContext.controlFlowNestingLevel; // this only needs to work right if no errors + + // then statement + if (! acceptScopedStatement(thenElse.node1)) { +@@ -3602,10 +3602,10 @@ bool HlslGrammar::acceptSelectionStatement(TIntermNode*& statement, const TAttri + + // Put the pieces together + statement = intermediate.addSelection(condition, thenElse, loc); +- parseContext.handleSelectionAttributes(loc, statement->getAsSelectionNode(), attributes); ++ _parseContext.handleSelectionAttributes(loc, statement->getAsSelectionNode(), attributes); + +- parseContext.popScope(); +- --parseContext.controlFlowNestingLevel; ++ _parseContext.popScope(); ++ --_parseContext.controlFlowNestingLevel; + + return true; + } +@@ -3622,26 +3622,26 @@ bool HlslGrammar::acceptSwitchStatement(TIntermNode*& statement, const TAttribut + return false; + + // LEFT_PAREN expression RIGHT_PAREN +- parseContext.pushScope(); ++ _parseContext.pushScope(); + TIntermTyped* switchExpression; + if (! acceptParenExpression(switchExpression)) { +- parseContext.popScope(); ++ _parseContext.popScope(); + return false; + } + + // compound_statement +- parseContext.pushSwitchSequence(new TIntermSequence); ++ _parseContext.pushSwitchSequence(new TIntermSequence); + +- ++parseContext.controlFlowNestingLevel; ++ ++_parseContext.controlFlowNestingLevel; + bool statementOkay = acceptCompoundStatement(statement); +- --parseContext.controlFlowNestingLevel; ++ --_parseContext.controlFlowNestingLevel; + + if (statementOkay) +- statement = parseContext.addSwitch(loc, switchExpression, statement ? statement->getAsAggregate() : nullptr, ++ statement = _parseContext.addSwitch(loc, switchExpression, statement ? statement->getAsAggregate() : nullptr, + attributes); + +- parseContext.popSwitchSequence(); +- parseContext.popScope(); ++ _parseContext.popSwitchSequence(); ++ _parseContext.popScope(); + + return statementOkay; + } +@@ -3668,14 +3668,14 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + case EHTokWhile: + // so that something declared in the condition is scoped to the lifetime + // of the while sub-statement +- parseContext.pushScope(); // this only needs to work right if no errors +- parseContext.nestLooping(); +- ++parseContext.controlFlowNestingLevel; ++ _parseContext.pushScope(); // this only needs to work right if no errors ++ _parseContext.nestLooping(); ++ ++_parseContext.controlFlowNestingLevel; + + // LEFT_PAREN condition RIGHT_PAREN + if (! acceptParenExpression(condition)) + return false; +- condition = parseContext.convertConditionalExpression(loc, condition); ++ condition = _parseContext.convertConditionalExpression(loc, condition); + if (condition == nullptr) + return false; + +@@ -3685,17 +3685,17 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + return false; + } + +- parseContext.unnestLooping(); +- parseContext.popScope(); +- --parseContext.controlFlowNestingLevel; ++ _parseContext.unnestLooping(); ++ _parseContext.popScope(); ++ --_parseContext.controlFlowNestingLevel; + + loopNode = intermediate.addLoop(statement, condition, nullptr, true, loc); + statement = loopNode; + break; + + case EHTokDo: +- parseContext.nestLooping(); // this only needs to work right if no errors +- ++parseContext.controlFlowNestingLevel; ++ _parseContext.nestLooping(); // this only needs to work right if no errors ++ ++_parseContext.controlFlowNestingLevel; + + // statement + if (! acceptScopedStatement(statement)) { +@@ -3712,15 +3712,15 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + // LEFT_PAREN condition RIGHT_PAREN + if (! acceptParenExpression(condition)) + return false; +- condition = parseContext.convertConditionalExpression(loc, condition); ++ condition = _parseContext.convertConditionalExpression(loc, condition); + if (condition == nullptr) + return false; + + if (! acceptTokenClass(EHTokSemicolon)) + expected(";"); + +- parseContext.unnestLooping(); +- --parseContext.controlFlowNestingLevel; ++ _parseContext.unnestLooping(); ++ --_parseContext.controlFlowNestingLevel; + + loopNode = intermediate.addLoop(statement, condition, 0, false, loc); + statement = loopNode; +@@ -3734,22 +3734,22 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + + // so that something declared in the condition is scoped to the lifetime + // of the for sub-statement +- parseContext.pushScope(); ++ _parseContext.pushScope(); + + // initializer + TIntermNode* initNode = nullptr; + if (! acceptSimpleStatement(initNode)) + expected("for-loop initializer statement"); + +- parseContext.nestLooping(); // this only needs to work right if no errors +- ++parseContext.controlFlowNestingLevel; ++ _parseContext.nestLooping(); // this only needs to work right if no errors ++ ++_parseContext.controlFlowNestingLevel; + + // condition SEMI_COLON + acceptExpression(condition); + if (! acceptTokenClass(EHTokSemicolon)) + expected(";"); + if (condition != nullptr) { +- condition = parseContext.convertConditionalExpression(loc, condition); ++ condition = _parseContext.convertConditionalExpression(loc, condition); + if (condition == nullptr) + return false; + } +@@ -3768,9 +3768,9 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + + statement = intermediate.addForLoop(statement, initNode, condition, iterator, true, loc, loopNode); + +- parseContext.popScope(); +- parseContext.unnestLooping(); +- --parseContext.controlFlowNestingLevel; ++ _parseContext.popScope(); ++ _parseContext.unnestLooping(); ++ --_parseContext.controlFlowNestingLevel; + + break; + } +@@ -3779,7 +3779,7 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri + return false; + } + +- parseContext.handleLoopAttributes(loc, loopNode, attributes); ++ _parseContext.handleLoopAttributes(loc, loopNode, attributes); + return true; + } + +@@ -3808,14 +3808,14 @@ bool HlslGrammar::acceptJumpStatement(TIntermNode*& statement) + switch (jump) { + case EHTokContinue: + statement = intermediate.addBranch(EOpContinue, token.loc); +- if (parseContext.loopNestingLevel == 0) { ++ if (_parseContext.loopNestingLevel == 0) { + expected("loop"); + return false; + } + break; + case EHTokBreak: + statement = intermediate.addBranch(EOpBreak, token.loc); +- if (parseContext.loopNestingLevel == 0 && parseContext.switchSequenceStack.size() == 0) { ++ if (_parseContext.loopNestingLevel == 0 && _parseContext.switchSequenceStack.size() == 0) { + expected("loop or switch"); + return false; + } +@@ -3830,7 +3830,7 @@ bool HlslGrammar::acceptJumpStatement(TIntermNode*& statement) + TIntermTyped* node; + if (acceptExpression(node)) { + // hook it up +- statement = parseContext.handleReturnValue(token.loc, node); ++ statement = _parseContext.handleReturnValue(token.loc, node); + } else + statement = intermediate.addBranch(EOpReturn, token.loc); + break; +@@ -3868,7 +3868,7 @@ bool HlslGrammar::acceptCaseLabel(TIntermNode*& statement) + return false; + } + +- statement = parseContext.intermediate.addBranch(EOpCase, expression, loc); ++ statement = _parseContext.intermediate.addBranch(EOpCase, expression, loc); + + return true; + } +@@ -3887,7 +3887,7 @@ bool HlslGrammar::acceptDefaultLabel(TIntermNode*& statement) + return false; + } + +- statement = parseContext.intermediate.addBranch(EOpDefault, loc); ++ statement = _parseContext.intermediate.addBranch(EOpDefault, loc); + + return true; + } +@@ -3922,7 +3922,7 @@ void HlslGrammar::acceptArraySpecifier(TArraySizes*& arraySizes) + + if (hasArraySize) { + TArraySize arraySize; +- parseContext.arraySizeCheck(loc, sizeExpr, arraySize); ++ _parseContext.arraySizeCheck(loc, sizeExpr, arraySize); + arraySizes->addInnerSize(arraySize); + } else { + arraySizes->addInnerSize(0); // sized by initializers. +@@ -3974,7 +3974,7 @@ bool HlslGrammar::acceptPostDecls(TQualifier& qualifier) + expected(")"); + break; + } +- parseContext.handlePackOffset(locationToken.loc, qualifier, *locationToken.string, componentToken.string); ++ _parseContext.handlePackOffset(locationToken.loc, qualifier, *locationToken.string, componentToken.string); + } else if (! acceptIdentifier(idToken)) { + expected("layout, semantic, packoffset, or register"); + return false; +@@ -4028,12 +4028,12 @@ bool HlslGrammar::acceptPostDecls(TQualifier& qualifier) + expected(")"); + break; + } +- parseContext.handleRegister(registerDesc.loc, qualifier, profile.string, *registerDesc.string, subComponent, spaceDesc.string); ++ _parseContext.handleRegister(registerDesc.loc, qualifier, profile.string, *registerDesc.string, subComponent, spaceDesc.string); + } else { + // semantic, in idToken.string + TString semanticUpperCase = *idToken.string; + std::transform(semanticUpperCase.begin(), semanticUpperCase.end(), semanticUpperCase.begin(), ::toupper); +- parseContext.handleSemantic(idToken.loc, qualifier, mapSemantic(semanticUpperCase.c_str()), semanticUpperCase); ++ _parseContext.handleSemantic(idToken.loc, qualifier, mapSemantic(semanticUpperCase.c_str()), semanticUpperCase); + } + } else if (peekTokenClass(EHTokLeftAngle)) { + found = true; +diff --git a/deps/glslang/glslang/hlsl/hlslGrammar.h b/deps/glslang/glslang/hlsl/hlslGrammar.h +index 046f7957e5..f15ccca0cf 100755 +--- a/deps/glslang/glslang/hlsl/hlslGrammar.h ++++ b/deps/glslang/glslang/hlsl/hlslGrammar.h +@@ -50,8 +50,8 @@ namespace glslang { + + class HlslGrammar : public HlslTokenStream { + public: +- HlslGrammar(HlslScanContext& scanner, HlslParseContext& parseContext) +- : HlslTokenStream(scanner), parseContext(parseContext), intermediate(parseContext.intermediate), ++ HlslGrammar(HlslScanContext& scanner, HlslParseContext& _parseContext) ++ : HlslTokenStream(scanner), _parseContext(_parseContext), intermediate(_parseContext.intermediate), + typeIdentifiers(false) { } + virtual ~HlslGrammar() { } + +@@ -130,7 +130,7 @@ namespace glslang { + bool captureBlockTokens(TVector& tokens); + const char* getTypeString(EHlslTokenClass tokenClass) const; + +- HlslParseContext& parseContext; // state of parsing and helper functions for building the intermediate ++ HlslParseContext& _parseContext; // state of parsing and helper functions for building the intermediate + TIntermediate& intermediate; // the final product, the intermediate representation, includes the AST + bool typeIdentifiers; // shader uses some types as identifiers + }; +diff --git a/deps/glslang/glslang/hlsl/hlslScanContext.cpp b/deps/glslang/glslang/hlsl/hlslScanContext.cpp +index 28a66bb47d..4414eb7aa8 100755 +--- a/deps/glslang/glslang/hlsl/hlslScanContext.cpp ++++ b/deps/glslang/glslang/hlsl/hlslScanContext.cpp +@@ -51,37 +51,15 @@ + // preprocessor includes + #include "../glslang/MachineIndependent/preprocessor/PpContext.h" + #include "../glslang/MachineIndependent/preprocessor/PpTokens.h" ++#include "../glslang/MachineIndependent/preprocessor/Compare.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* KeywordMap = nullptr; +-std::unordered_set* ReservedSet = nullptr; +-std::unordered_map* SemanticMap = nullptr; ++std::unordered_map* hlslKeywordMap = nullptr; ++std::unordered_set* hlslReservedSet = nullptr; ++std::unordered_map* hlslSemanticMap = nullptr; + + }; + +@@ -89,323 +67,323 @@ namespace glslang { + + void HlslScanContext::fillInKeywordMap() + { +- if (KeywordMap != nullptr) { ++ if (hlslKeywordMap != 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; +- +- (*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; ++ hlslKeywordMap = new std::unordered_map; ++ ++ (*hlslKeywordMap)["static"] = EHTokStatic; ++ (*hlslKeywordMap)["const"] = EHTokConst; ++ (*hlslKeywordMap)["unorm"] = EHTokUnorm; ++ (*hlslKeywordMap)["snorm"] = EHTokSNorm; ++ (*hlslKeywordMap)["extern"] = EHTokExtern; ++ (*hlslKeywordMap)["uniform"] = EHTokUniform; ++ (*hlslKeywordMap)["volatile"] = EHTokVolatile; ++ (*hlslKeywordMap)["precise"] = EHTokPrecise; ++ (*hlslKeywordMap)["shared"] = EHTokShared; ++ (*hlslKeywordMap)["groupshared"] = EHTokGroupShared; ++ (*hlslKeywordMap)["linear"] = EHTokLinear; ++ (*hlslKeywordMap)["centroid"] = EHTokCentroid; ++ (*hlslKeywordMap)["nointerpolation"] = EHTokNointerpolation; ++ (*hlslKeywordMap)["noperspective"] = EHTokNoperspective; ++ (*hlslKeywordMap)["sample"] = EHTokSample; ++ (*hlslKeywordMap)["row_major"] = EHTokRowMajor; ++ (*hlslKeywordMap)["column_major"] = EHTokColumnMajor; ++ (*hlslKeywordMap)["packoffset"] = EHTokPackOffset; ++ (*hlslKeywordMap)["in"] = EHTokIn; ++ (*hlslKeywordMap)["out"] = EHTokOut; ++ (*hlslKeywordMap)["inout"] = EHTokInOut; ++ (*hlslKeywordMap)["layout"] = EHTokLayout; ++ (*hlslKeywordMap)["globallycoherent"] = EHTokGloballyCoherent; ++ (*hlslKeywordMap)["inline"] = EHTokInline; ++ ++ (*hlslKeywordMap)["point"] = EHTokPoint; ++ (*hlslKeywordMap)["line"] = EHTokLine; ++ (*hlslKeywordMap)["triangle"] = EHTokTriangle; ++ (*hlslKeywordMap)["lineadj"] = EHTokLineAdj; ++ (*hlslKeywordMap)["triangleadj"] = EHTokTriangleAdj; ++ ++ (*hlslKeywordMap)["PointStream"] = EHTokPointStream; ++ (*hlslKeywordMap)["LineStream"] = EHTokLineStream; ++ (*hlslKeywordMap)["TriangleStream"] = EHTokTriangleStream; ++ ++ (*hlslKeywordMap)["InputPatch"] = EHTokInputPatch; ++ (*hlslKeywordMap)["OutputPatch"] = EHTokOutputPatch; ++ ++ (*hlslKeywordMap)["Buffer"] = EHTokBuffer; ++ (*hlslKeywordMap)["vector"] = EHTokVector; ++ (*hlslKeywordMap)["matrix"] = EHTokMatrix; ++ ++ (*hlslKeywordMap)["void"] = EHTokVoid; ++ (*hlslKeywordMap)["string"] = EHTokString; ++ (*hlslKeywordMap)["bool"] = EHTokBool; ++ (*hlslKeywordMap)["int"] = EHTokInt; ++ (*hlslKeywordMap)["uint"] = EHTokUint; ++ (*hlslKeywordMap)["uint64_t"] = EHTokUint64; ++ (*hlslKeywordMap)["dword"] = EHTokDword; ++ (*hlslKeywordMap)["half"] = EHTokHalf; ++ (*hlslKeywordMap)["float"] = EHTokFloat; ++ (*hlslKeywordMap)["double"] = EHTokDouble; ++ (*hlslKeywordMap)["min16float"] = EHTokMin16float; ++ (*hlslKeywordMap)["min10float"] = EHTokMin10float; ++ (*hlslKeywordMap)["min16int"] = EHTokMin16int; ++ (*hlslKeywordMap)["min12int"] = EHTokMin12int; ++ (*hlslKeywordMap)["min16uint"] = EHTokMin16uint; ++ ++ (*hlslKeywordMap)["bool1"] = EHTokBool1; ++ (*hlslKeywordMap)["bool2"] = EHTokBool2; ++ (*hlslKeywordMap)["bool3"] = EHTokBool3; ++ (*hlslKeywordMap)["bool4"] = EHTokBool4; ++ (*hlslKeywordMap)["float1"] = EHTokFloat1; ++ (*hlslKeywordMap)["float2"] = EHTokFloat2; ++ (*hlslKeywordMap)["float3"] = EHTokFloat3; ++ (*hlslKeywordMap)["float4"] = EHTokFloat4; ++ (*hlslKeywordMap)["int1"] = EHTokInt1; ++ (*hlslKeywordMap)["int2"] = EHTokInt2; ++ (*hlslKeywordMap)["int3"] = EHTokInt3; ++ (*hlslKeywordMap)["int4"] = EHTokInt4; ++ (*hlslKeywordMap)["double1"] = EHTokDouble1; ++ (*hlslKeywordMap)["double2"] = EHTokDouble2; ++ (*hlslKeywordMap)["double3"] = EHTokDouble3; ++ (*hlslKeywordMap)["double4"] = EHTokDouble4; ++ (*hlslKeywordMap)["uint1"] = EHTokUint1; ++ (*hlslKeywordMap)["uint2"] = EHTokUint2; ++ (*hlslKeywordMap)["uint3"] = EHTokUint3; ++ (*hlslKeywordMap)["uint4"] = EHTokUint4; ++ ++ (*hlslKeywordMap)["half1"] = EHTokHalf1; ++ (*hlslKeywordMap)["half2"] = EHTokHalf2; ++ (*hlslKeywordMap)["half3"] = EHTokHalf3; ++ (*hlslKeywordMap)["half4"] = EHTokHalf4; ++ (*hlslKeywordMap)["min16float1"] = EHTokMin16float1; ++ (*hlslKeywordMap)["min16float2"] = EHTokMin16float2; ++ (*hlslKeywordMap)["min16float3"] = EHTokMin16float3; ++ (*hlslKeywordMap)["min16float4"] = EHTokMin16float4; ++ (*hlslKeywordMap)["min10float1"] = EHTokMin10float1; ++ (*hlslKeywordMap)["min10float2"] = EHTokMin10float2; ++ (*hlslKeywordMap)["min10float3"] = EHTokMin10float3; ++ (*hlslKeywordMap)["min10float4"] = EHTokMin10float4; ++ (*hlslKeywordMap)["min16int1"] = EHTokMin16int1; ++ (*hlslKeywordMap)["min16int2"] = EHTokMin16int2; ++ (*hlslKeywordMap)["min16int3"] = EHTokMin16int3; ++ (*hlslKeywordMap)["min16int4"] = EHTokMin16int4; ++ (*hlslKeywordMap)["min12int1"] = EHTokMin12int1; ++ (*hlslKeywordMap)["min12int2"] = EHTokMin12int2; ++ (*hlslKeywordMap)["min12int3"] = EHTokMin12int3; ++ (*hlslKeywordMap)["min12int4"] = EHTokMin12int4; ++ (*hlslKeywordMap)["min16uint1"] = EHTokMin16uint1; ++ (*hlslKeywordMap)["min16uint2"] = EHTokMin16uint2; ++ (*hlslKeywordMap)["min16uint3"] = EHTokMin16uint3; ++ (*hlslKeywordMap)["min16uint4"] = EHTokMin16uint4; ++ ++ (*hlslKeywordMap)["bool1x1"] = EHTokBool1x1; ++ (*hlslKeywordMap)["bool1x2"] = EHTokBool1x2; ++ (*hlslKeywordMap)["bool1x3"] = EHTokBool1x3; ++ (*hlslKeywordMap)["bool1x4"] = EHTokBool1x4; ++ (*hlslKeywordMap)["bool2x1"] = EHTokBool2x1; ++ (*hlslKeywordMap)["bool2x2"] = EHTokBool2x2; ++ (*hlslKeywordMap)["bool2x3"] = EHTokBool2x3; ++ (*hlslKeywordMap)["bool2x4"] = EHTokBool2x4; ++ (*hlslKeywordMap)["bool3x1"] = EHTokBool3x1; ++ (*hlslKeywordMap)["bool3x2"] = EHTokBool3x2; ++ (*hlslKeywordMap)["bool3x3"] = EHTokBool3x3; ++ (*hlslKeywordMap)["bool3x4"] = EHTokBool3x4; ++ (*hlslKeywordMap)["bool4x1"] = EHTokBool4x1; ++ (*hlslKeywordMap)["bool4x2"] = EHTokBool4x2; ++ (*hlslKeywordMap)["bool4x3"] = EHTokBool4x3; ++ (*hlslKeywordMap)["bool4x4"] = EHTokBool4x4; ++ (*hlslKeywordMap)["int1x1"] = EHTokInt1x1; ++ (*hlslKeywordMap)["int1x2"] = EHTokInt1x2; ++ (*hlslKeywordMap)["int1x3"] = EHTokInt1x3; ++ (*hlslKeywordMap)["int1x4"] = EHTokInt1x4; ++ (*hlslKeywordMap)["int2x1"] = EHTokInt2x1; ++ (*hlslKeywordMap)["int2x2"] = EHTokInt2x2; ++ (*hlslKeywordMap)["int2x3"] = EHTokInt2x3; ++ (*hlslKeywordMap)["int2x4"] = EHTokInt2x4; ++ (*hlslKeywordMap)["int3x1"] = EHTokInt3x1; ++ (*hlslKeywordMap)["int3x2"] = EHTokInt3x2; ++ (*hlslKeywordMap)["int3x3"] = EHTokInt3x3; ++ (*hlslKeywordMap)["int3x4"] = EHTokInt3x4; ++ (*hlslKeywordMap)["int4x1"] = EHTokInt4x1; ++ (*hlslKeywordMap)["int4x2"] = EHTokInt4x2; ++ (*hlslKeywordMap)["int4x3"] = EHTokInt4x3; ++ (*hlslKeywordMap)["int4x4"] = EHTokInt4x4; ++ (*hlslKeywordMap)["uint1x1"] = EHTokUint1x1; ++ (*hlslKeywordMap)["uint1x2"] = EHTokUint1x2; ++ (*hlslKeywordMap)["uint1x3"] = EHTokUint1x3; ++ (*hlslKeywordMap)["uint1x4"] = EHTokUint1x4; ++ (*hlslKeywordMap)["uint2x1"] = EHTokUint2x1; ++ (*hlslKeywordMap)["uint2x2"] = EHTokUint2x2; ++ (*hlslKeywordMap)["uint2x3"] = EHTokUint2x3; ++ (*hlslKeywordMap)["uint2x4"] = EHTokUint2x4; ++ (*hlslKeywordMap)["uint3x1"] = EHTokUint3x1; ++ (*hlslKeywordMap)["uint3x2"] = EHTokUint3x2; ++ (*hlslKeywordMap)["uint3x3"] = EHTokUint3x3; ++ (*hlslKeywordMap)["uint3x4"] = EHTokUint3x4; ++ (*hlslKeywordMap)["uint4x1"] = EHTokUint4x1; ++ (*hlslKeywordMap)["uint4x2"] = EHTokUint4x2; ++ (*hlslKeywordMap)["uint4x3"] = EHTokUint4x3; ++ (*hlslKeywordMap)["uint4x4"] = EHTokUint4x4; ++ (*hlslKeywordMap)["bool1x1"] = EHTokBool1x1; ++ (*hlslKeywordMap)["bool1x2"] = EHTokBool1x2; ++ (*hlslKeywordMap)["bool1x3"] = EHTokBool1x3; ++ (*hlslKeywordMap)["bool1x4"] = EHTokBool1x4; ++ (*hlslKeywordMap)["bool2x1"] = EHTokBool2x1; ++ (*hlslKeywordMap)["bool2x2"] = EHTokBool2x2; ++ (*hlslKeywordMap)["bool2x3"] = EHTokBool2x3; ++ (*hlslKeywordMap)["bool2x4"] = EHTokBool2x4; ++ (*hlslKeywordMap)["bool3x1"] = EHTokBool3x1; ++ (*hlslKeywordMap)["bool3x2"] = EHTokBool3x2; ++ (*hlslKeywordMap)["bool3x3"] = EHTokBool3x3; ++ (*hlslKeywordMap)["bool3x4"] = EHTokBool3x4; ++ (*hlslKeywordMap)["bool4x1"] = EHTokBool4x1; ++ (*hlslKeywordMap)["bool4x2"] = EHTokBool4x2; ++ (*hlslKeywordMap)["bool4x3"] = EHTokBool4x3; ++ (*hlslKeywordMap)["bool4x4"] = EHTokBool4x4; ++ (*hlslKeywordMap)["float1x1"] = EHTokFloat1x1; ++ (*hlslKeywordMap)["float1x2"] = EHTokFloat1x2; ++ (*hlslKeywordMap)["float1x3"] = EHTokFloat1x3; ++ (*hlslKeywordMap)["float1x4"] = EHTokFloat1x4; ++ (*hlslKeywordMap)["float2x1"] = EHTokFloat2x1; ++ (*hlslKeywordMap)["float2x2"] = EHTokFloat2x2; ++ (*hlslKeywordMap)["float2x3"] = EHTokFloat2x3; ++ (*hlslKeywordMap)["float2x4"] = EHTokFloat2x4; ++ (*hlslKeywordMap)["float3x1"] = EHTokFloat3x1; ++ (*hlslKeywordMap)["float3x2"] = EHTokFloat3x2; ++ (*hlslKeywordMap)["float3x3"] = EHTokFloat3x3; ++ (*hlslKeywordMap)["float3x4"] = EHTokFloat3x4; ++ (*hlslKeywordMap)["float4x1"] = EHTokFloat4x1; ++ (*hlslKeywordMap)["float4x2"] = EHTokFloat4x2; ++ (*hlslKeywordMap)["float4x3"] = EHTokFloat4x3; ++ (*hlslKeywordMap)["float4x4"] = EHTokFloat4x4; ++ (*hlslKeywordMap)["half1x1"] = EHTokHalf1x1; ++ (*hlslKeywordMap)["half1x2"] = EHTokHalf1x2; ++ (*hlslKeywordMap)["half1x3"] = EHTokHalf1x3; ++ (*hlslKeywordMap)["half1x4"] = EHTokHalf1x4; ++ (*hlslKeywordMap)["half2x1"] = EHTokHalf2x1; ++ (*hlslKeywordMap)["half2x2"] = EHTokHalf2x2; ++ (*hlslKeywordMap)["half2x3"] = EHTokHalf2x3; ++ (*hlslKeywordMap)["half2x4"] = EHTokHalf2x4; ++ (*hlslKeywordMap)["half3x1"] = EHTokHalf3x1; ++ (*hlslKeywordMap)["half3x2"] = EHTokHalf3x2; ++ (*hlslKeywordMap)["half3x3"] = EHTokHalf3x3; ++ (*hlslKeywordMap)["half3x4"] = EHTokHalf3x4; ++ (*hlslKeywordMap)["half4x1"] = EHTokHalf4x1; ++ (*hlslKeywordMap)["half4x2"] = EHTokHalf4x2; ++ (*hlslKeywordMap)["half4x3"] = EHTokHalf4x3; ++ (*hlslKeywordMap)["half4x4"] = EHTokHalf4x4; ++ (*hlslKeywordMap)["double1x1"] = EHTokDouble1x1; ++ (*hlslKeywordMap)["double1x2"] = EHTokDouble1x2; ++ (*hlslKeywordMap)["double1x3"] = EHTokDouble1x3; ++ (*hlslKeywordMap)["double1x4"] = EHTokDouble1x4; ++ (*hlslKeywordMap)["double2x1"] = EHTokDouble2x1; ++ (*hlslKeywordMap)["double2x2"] = EHTokDouble2x2; ++ (*hlslKeywordMap)["double2x3"] = EHTokDouble2x3; ++ (*hlslKeywordMap)["double2x4"] = EHTokDouble2x4; ++ (*hlslKeywordMap)["double3x1"] = EHTokDouble3x1; ++ (*hlslKeywordMap)["double3x2"] = EHTokDouble3x2; ++ (*hlslKeywordMap)["double3x3"] = EHTokDouble3x3; ++ (*hlslKeywordMap)["double3x4"] = EHTokDouble3x4; ++ (*hlslKeywordMap)["double4x1"] = EHTokDouble4x1; ++ (*hlslKeywordMap)["double4x2"] = EHTokDouble4x2; ++ (*hlslKeywordMap)["double4x3"] = EHTokDouble4x3; ++ (*hlslKeywordMap)["double4x4"] = EHTokDouble4x4; ++ ++ (*hlslKeywordMap)["sampler"] = EHTokSampler; ++ (*hlslKeywordMap)["sampler1D"] = EHTokSampler1d; ++ (*hlslKeywordMap)["sampler2D"] = EHTokSampler2d; ++ (*hlslKeywordMap)["sampler3D"] = EHTokSampler3d; ++ (*hlslKeywordMap)["samplerCube"] = EHTokSamplerCube; ++ (*hlslKeywordMap)["sampler_state"] = EHTokSamplerState; ++ (*hlslKeywordMap)["SamplerState"] = EHTokSamplerState; ++ (*hlslKeywordMap)["SamplerComparisonState"] = EHTokSamplerComparisonState; ++ (*hlslKeywordMap)["texture"] = EHTokTexture; ++ (*hlslKeywordMap)["Texture1D"] = EHTokTexture1d; ++ (*hlslKeywordMap)["Texture1DArray"] = EHTokTexture1darray; ++ (*hlslKeywordMap)["Texture2D"] = EHTokTexture2d; ++ (*hlslKeywordMap)["Texture2DArray"] = EHTokTexture2darray; ++ (*hlslKeywordMap)["Texture3D"] = EHTokTexture3d; ++ (*hlslKeywordMap)["TextureCube"] = EHTokTextureCube; ++ (*hlslKeywordMap)["TextureCubeArray"] = EHTokTextureCubearray; ++ (*hlslKeywordMap)["Texture2DMS"] = EHTokTexture2DMS; ++ (*hlslKeywordMap)["Texture2DMSArray"] = EHTokTexture2DMSarray; ++ (*hlslKeywordMap)["RWTexture1D"] = EHTokRWTexture1d; ++ (*hlslKeywordMap)["RWTexture1DArray"] = EHTokRWTexture1darray; ++ (*hlslKeywordMap)["RWTexture2D"] = EHTokRWTexture2d; ++ (*hlslKeywordMap)["RWTexture2DArray"] = EHTokRWTexture2darray; ++ (*hlslKeywordMap)["RWTexture3D"] = EHTokRWTexture3d; ++ (*hlslKeywordMap)["RWBuffer"] = EHTokRWBuffer; ++ (*hlslKeywordMap)["SubpassInput"] = EHTokSubpassInput; ++ (*hlslKeywordMap)["SubpassInputMS"] = EHTokSubpassInputMS; ++ ++ (*hlslKeywordMap)["AppendStructuredBuffer"] = EHTokAppendStructuredBuffer; ++ (*hlslKeywordMap)["ByteAddressBuffer"] = EHTokByteAddressBuffer; ++ (*hlslKeywordMap)["ConsumeStructuredBuffer"] = EHTokConsumeStructuredBuffer; ++ (*hlslKeywordMap)["RWByteAddressBuffer"] = EHTokRWByteAddressBuffer; ++ (*hlslKeywordMap)["RWStructuredBuffer"] = EHTokRWStructuredBuffer; ++ (*hlslKeywordMap)["StructuredBuffer"] = EHTokStructuredBuffer; ++ (*hlslKeywordMap)["TextureBuffer"] = EHTokTextureBuffer; ++ ++ (*hlslKeywordMap)["class"] = EHTokClass; ++ (*hlslKeywordMap)["struct"] = EHTokStruct; ++ (*hlslKeywordMap)["cbuffer"] = EHTokCBuffer; ++ (*hlslKeywordMap)["ConstantBuffer"] = EHTokConstantBuffer; ++ (*hlslKeywordMap)["tbuffer"] = EHTokTBuffer; ++ (*hlslKeywordMap)["typedef"] = EHTokTypedef; ++ (*hlslKeywordMap)["this"] = EHTokThis; ++ (*hlslKeywordMap)["namespace"] = EHTokNamespace; ++ ++ (*hlslKeywordMap)["true"] = EHTokBoolConstant; ++ (*hlslKeywordMap)["false"] = EHTokBoolConstant; ++ ++ (*hlslKeywordMap)["for"] = EHTokFor; ++ (*hlslKeywordMap)["do"] = EHTokDo; ++ (*hlslKeywordMap)["while"] = EHTokWhile; ++ (*hlslKeywordMap)["break"] = EHTokBreak; ++ (*hlslKeywordMap)["continue"] = EHTokContinue; ++ (*hlslKeywordMap)["if"] = EHTokIf; ++ (*hlslKeywordMap)["else"] = EHTokElse; ++ (*hlslKeywordMap)["discard"] = EHTokDiscard; ++ (*hlslKeywordMap)["return"] = EHTokReturn; ++ (*hlslKeywordMap)["switch"] = EHTokSwitch; ++ (*hlslKeywordMap)["case"] = EHTokCase; ++ (*hlslKeywordMap)["default"] = EHTokDefault; + + // TODO: get correct set here +- ReservedSet = new std::unordered_set; +- +- 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; ++ hlslReservedSet = new std::unordered_set; ++ ++ hlslReservedSet->insert("auto"); ++ hlslReservedSet->insert("catch"); ++ hlslReservedSet->insert("char"); ++ hlslReservedSet->insert("const_cast"); ++ hlslReservedSet->insert("enum"); ++ hlslReservedSet->insert("explicit"); ++ hlslReservedSet->insert("friend"); ++ hlslReservedSet->insert("goto"); ++ hlslReservedSet->insert("long"); ++ hlslReservedSet->insert("mutable"); ++ hlslReservedSet->insert("new"); ++ hlslReservedSet->insert("operator"); ++ hlslReservedSet->insert("private"); ++ hlslReservedSet->insert("protected"); ++ hlslReservedSet->insert("public"); ++ hlslReservedSet->insert("reinterpret_cast"); ++ hlslReservedSet->insert("short"); ++ hlslReservedSet->insert("signed"); ++ hlslReservedSet->insert("sizeof"); ++ hlslReservedSet->insert("static_cast"); ++ hlslReservedSet->insert("template"); ++ hlslReservedSet->insert("throw"); ++ hlslReservedSet->insert("try"); ++ hlslReservedSet->insert("typename"); ++ hlslReservedSet->insert("union"); ++ hlslReservedSet->insert("unsigned"); ++ hlslReservedSet->insert("using"); ++ hlslReservedSet->insert("virtual"); ++ ++ hlslSemanticMap = new std::unordered_map; + + // 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 +@@ -416,45 +394,45 @@ void HlslScanContext::fillInKeywordMap() + // to the next + bool bParseDX9 = false; + if (bParseDX9) { +- (*SemanticMap)["PSIZE"] = EbvPointSize; +- (*SemanticMap)["FOG"] = EbvFogFragCoord; +- (*SemanticMap)["DEPTH"] = EbvFragDepth; +- (*SemanticMap)["VFACE"] = EbvFace; +- (*SemanticMap)["VPOS"] = EbvFragCoord; ++ (*hlslSemanticMap)["PSIZE"] = EbvPointSize; ++ (*hlslSemanticMap)["FOG"] = EbvFogFragCoord; ++ (*hlslSemanticMap)["DEPTH"] = EbvFragDepth; ++ (*hlslSemanticMap)["VFACE"] = EbvFace; ++ (*hlslSemanticMap)["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; ++ (*hlslSemanticMap)["SV_POSITION"] = EbvPosition; ++ (*hlslSemanticMap)["SV_VERTEXID"] = EbvVertexIndex; ++ (*hlslSemanticMap)["SV_VIEWPORTARRAYINDEX"] = EbvViewportIndex; ++ (*hlslSemanticMap)["SV_TESSFACTOR"] = EbvTessLevelOuter; ++ (*hlslSemanticMap)["SV_SAMPLEINDEX"] = EbvSampleId; ++ (*hlslSemanticMap)["SV_RENDERTARGETARRAYINDEX"] = EbvLayer; ++ (*hlslSemanticMap)["SV_PRIMITIVEID"] = EbvPrimitiveId; ++ (*hlslSemanticMap)["SV_OUTPUTCONTROLPOINTID"] = EbvInvocationId; ++ (*hlslSemanticMap)["SV_ISFRONTFACE"] = EbvFace; ++ (*hlslSemanticMap)["SV_INSTANCEID"] = EbvInstanceIndex; ++ (*hlslSemanticMap)["SV_INSIDETESSFACTOR"] = EbvTessLevelInner; ++ (*hlslSemanticMap)["SV_GSINSTANCEID"] = EbvInvocationId; ++ (*hlslSemanticMap)["SV_DISPATCHTHREADID"] = EbvGlobalInvocationId; ++ (*hlslSemanticMap)["SV_GROUPTHREADID"] = EbvLocalInvocationId; ++ (*hlslSemanticMap)["SV_GROUPINDEX"] = EbvLocalInvocationIndex; ++ (*hlslSemanticMap)["SV_GROUPID"] = EbvWorkGroupId; ++ (*hlslSemanticMap)["SV_DOMAINLOCATION"] = EbvTessCoord; ++ (*hlslSemanticMap)["SV_DEPTH"] = EbvFragDepth; ++ (*hlslSemanticMap)["SV_COVERAGE"] = EbvSampleMask; ++ (*hlslSemanticMap)["SV_DEPTHGREATEREQUAL"] = EbvFragDepthGreater; ++ (*hlslSemanticMap)["SV_DEPTHLESSEQUAL"] = EbvFragDepthLesser; ++ (*hlslSemanticMap)["SV_STENCILREF"] = EbvFragStencilRef; + } + + void HlslScanContext::deleteKeywordMap() + { +- delete KeywordMap; +- KeywordMap = nullptr; +- delete ReservedSet; +- ReservedSet = nullptr; +- delete SemanticMap; +- SemanticMap = nullptr; ++ delete hlslKeywordMap; ++ hlslKeywordMap = nullptr; ++ delete hlslReservedSet; ++ hlslReservedSet = nullptr; ++ delete hlslSemanticMap; ++ hlslSemanticMap = nullptr; + } + + // Wrapper for tokenizeClass() to get everything inside the token. +@@ -466,8 +444,8 @@ void HlslScanContext::tokenize(HlslToken& token) + + glslang::TBuiltInVariable HlslScanContext::mapSemantic(const char* upperCase) + { +- auto it = SemanticMap->find(upperCase); +- if (it != SemanticMap->end()) ++ auto it = hlslSemanticMap->find(upperCase); ++ if (it != hlslSemanticMap->end()) + return it->second; + else + return glslang::EbvNone; +@@ -516,7 +494,7 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) + case '{': return EHTokLeftBrace; + case '}': return EHTokRightBrace; + case '\\': +- parseContext.error(loc, "illegal use of escape character", "\\", ""); ++ _parseContext.error(loc, "illegal use of escape character", "\\", ""); + break; + + case PPAtomAddAssign: return EHTokAddAssign; +@@ -571,11 +549,11 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) + char buf[2]; + buf[0] = (char)token; + buf[1] = 0; +- parseContext.error(loc, "unexpected token", buf, ""); ++ _parseContext.error(loc, "unexpected token", buf, ""); + } else if (tokenText[0] != 0) +- parseContext.error(loc, "unexpected token", tokenText, ""); ++ _parseContext.error(loc, "unexpected token", tokenText, ""); + else +- parseContext.error(loc, "unexpected token", "", ""); ++ _parseContext.error(loc, "unexpected token", "", ""); + break; + } + } while (true); +@@ -583,11 +561,11 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) + + EHlslTokenClass HlslScanContext::tokenizeIdentifier() + { +- if (ReservedSet->find(tokenText) != ReservedSet->end()) ++ if (hlslReservedSet->find(tokenText) != hlslReservedSet->end()) + return reservedWord(); + +- auto it = KeywordMap->find(tokenText); +- if (it == KeywordMap->end()) { ++ auto it = hlslKeywordMap->find(tokenText); ++ if (it == hlslKeywordMap->end()) { + // Should have an identifier of some sort + return identifierOrType(); + } +@@ -877,7 +855,7 @@ EHlslTokenClass HlslScanContext::tokenizeIdentifier() + return keyword; + + default: +- parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); ++ _parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); + return EHTokNone; + } + } +@@ -894,8 +872,8 @@ EHlslTokenClass HlslScanContext::identifierOrType() + // extension support before the extension is enabled. + EHlslTokenClass HlslScanContext::reservedWord() + { +- if (! parseContext.symbolTable.atBuiltInLevel()) +- parseContext.error(loc, "Reserved word.", tokenText, "", ""); ++ if (! _parseContext.symbolTable.atBuiltInLevel()) ++ _parseContext.error(loc, "Reserved word.", tokenText, "", ""); + + return EHTokNone; + } +diff --git a/deps/glslang/glslang/hlsl/hlslScanContext.h b/deps/glslang/glslang/hlsl/hlslScanContext.h +index 9d30a12e1e..f7912c8d9b 100755 +--- a/deps/glslang/glslang/hlsl/hlslScanContext.h ++++ b/deps/glslang/glslang/hlsl/hlslScanContext.h +@@ -73,8 +73,8 @@ struct HlslToken { + // + class HlslScanContext { + public: +- HlslScanContext(TParseContextBase& parseContext, TPpContext& ppContext) +- : parseContext(parseContext), ppContext(ppContext) { } ++ HlslScanContext(TParseContextBase& _parseContext, TPpContext& ppContext) ++ : _parseContext(_parseContext), ppContext(ppContext) { } + virtual ~HlslScanContext() { } + + static void fillInKeywordMap(); +@@ -94,7 +94,7 @@ protected: + EHlslTokenClass identifierOrReserved(bool reserved); + EHlslTokenClass nonreservedKeyword(int version); + +- TParseContextBase& parseContext; ++ TParseContextBase& _parseContext; + TPpContext& ppContext; + TSourceLoc loc; + TPpToken* ppToken; diff --git a/deps/glslang/glslang/SPIRV/doc.h b/deps/glslang/glslang/SPIRV/doc.h index 7d0475d3eb..eb6b4b963e 100644 --- a/deps/glslang/glslang/SPIRV/doc.h +++ b/deps/glslang/glslang/SPIRV/doc.h @@ -32,6 +32,9 @@ // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. +#ifndef _SPIRV_doc_h +#define _SPIRV_doc_h + // // Parameterize the SPIR-V enumerants. // @@ -256,3 +259,5 @@ const char* AccessQualifierString(int attr); void PrintOperands(const OperandParameters& operands, int reservedOperands); }; // end namespace spv + +#endif diff --git a/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h b/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h index 7333bc964e..fcb1fa9bb7 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h +++ b/deps/glslang/glslang/glslang/MachineIndependent/LiveTraverser.h @@ -33,6 +33,9 @@ // POSSIBILITY OF SUCH DAMAGE. // +#ifndef _MACHINE_INDEPENDENT_LIVE_TRAVERSER_H +#define _MACHINE_INDEPENDENT_LIVE_TRAVERSER_H + #pragma once #include "../Include/Common.h" @@ -136,3 +139,5 @@ private: }; } // namespace glslang + +#endif diff --git a/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp b/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp index aa21d8a11e..0464f965fd 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/Scan.cpp @@ -54,6 +54,7 @@ // preprocessor includes #include "preprocessor/PpContext.h" #include "preprocessor/PpTokens.h" +#include "preprocessor/Compare.h" // Required to avoid missing prototype warnings for some compilers int yylex(YYSTYPE*, glslang::TParseContext&); @@ -289,38 +290,15 @@ protected: } // end namespace glslang // This is the function the glslang parser (i.e., bison) calls to get its next token -int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& parseContext) +int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& _parseContext) { glslang::TParserToken token(*glslangTokenDesc); - return parseContext.getScanContext()->tokenize(parseContext.getPpContext(), token); + return _parseContext.getScanContext()->tokenize(_parseContext.getPpContext(), token); } 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* KeywordMap = nullptr; @@ -781,7 +759,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case '{': afterStruct = false; return LEFT_BRACE; case '}': return RIGHT_BRACE; case '\\': - parseContext.error(loc, "illegal use of escape character", "\\", ""); + _parseContext.error(loc, "illegal use of escape character", "\\", ""); break; case PPAtomAddAssign: return ADD_ASSIGN; @@ -812,7 +790,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case PpAtomIncrement: return INC_OP; case PpAtomColonColon: - parseContext.error(loc, "not supported", "::", ""); + _parseContext.error(loc, "not supported", "::", ""); break; case PpAtomConstInt: parserToken->sType.lex.i = ppToken.ival; return INTCONSTANT; @@ -837,7 +815,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) char buf[2]; buf[0] = (char)token; buf[1] = 0; - parseContext.error(loc, "unexpected token", buf, ""); + _parseContext.error(loc, "unexpected token", buf, ""); break; } } while (true); @@ -878,15 +856,15 @@ int TScanContext::tokenizeIdentifier() return keyword; case NONUNIFORM: - if (parseContext.extensionTurnedOn(E_GL_EXT_nonuniform_qualifier)) + if (_parseContext.extensionTurnedOn(E_GL_EXT_nonuniform_qualifier)) return keyword; else return identifierOrType(); case SWITCH: case DEFAULT: - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 130)) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 130)) reservedWord(); return keyword; @@ -920,19 +898,19 @@ int TScanContext::tokenizeIdentifier() case ATTRIBUTE: case VARYING: - if (parseContext.profile == EEsProfile && parseContext.version >= 300) + if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) reservedWord(); return keyword; case BUFFER: - if ((parseContext.profile == EEsProfile && parseContext.version < 310) || - (parseContext.profile != EEsProfile && parseContext.version < 430)) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 310) || + (_parseContext.profile != EEsProfile && _parseContext.version < 430)) return identifierOrType(); return keyword; case ATOMIC_UINT: - if ((parseContext.profile == EEsProfile && parseContext.version >= 310) || - parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 310) || + _parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters)) return keyword; return es30ReservedFromGLSL(420); @@ -940,15 +918,15 @@ int TScanContext::tokenizeIdentifier() case RESTRICT: case READONLY: case WRITEONLY: - if (parseContext.profile == EEsProfile && parseContext.version >= 310) + if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) return keyword; - return es30ReservedFromGLSL(parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store) ? 130 : 420); + return es30ReservedFromGLSL(_parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store) ? 130 : 420); case VOLATILE: - if (parseContext.profile == EEsProfile && parseContext.version >= 310) + if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) return keyword; - if (! parseContext.symbolTable.atBuiltInLevel() && (parseContext.profile == EEsProfile || - (parseContext.version < 420 && ! parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) + if (! _parseContext.symbolTable.atBuiltInLevel() && (_parseContext.profile == EEsProfile || + (_parseContext.version < 420 && ! _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) reservedWord(); return keyword; @@ -957,31 +935,31 @@ int TScanContext::tokenizeIdentifier() const int numLayoutExts = 2; const char* layoutExts[numLayoutExts] = { E_GL_ARB_shading_language_420pack, E_GL_ARB_explicit_attrib_location }; - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 140 && - ! parseContext.extensionsTurnedOn(numLayoutExts, layoutExts))) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 140 && + ! _parseContext.extensionsTurnedOn(numLayoutExts, layoutExts))) return identifierOrType(); return keyword; } case SHARED: - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 140)) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 140)) return identifierOrType(); return keyword; case PATCH: - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile == EEsProfile && - (parseContext.version >= 320 || - parseContext.extensionsTurnedOn(Num_AEP_tessellation_shader, AEP_tessellation_shader))) || - (parseContext.profile != EEsProfile && parseContext.extensionTurnedOn(E_GL_ARB_tessellation_shader))) + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile == EEsProfile && + (_parseContext.version >= 320 || + _parseContext.extensionsTurnedOn(Num_AEP_tessellation_shader, AEP_tessellation_shader))) || + (_parseContext.profile != EEsProfile && _parseContext.extensionTurnedOn(E_GL_ARB_tessellation_shader))) return keyword; return es30ReservedFromGLSL(400); case SAMPLE: - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(1, &E_GL_OES_shader_multisample_interpolation)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(1, &E_GL_OES_shader_multisample_interpolation)) return keyword; return es30ReservedFromGLSL(400); @@ -1035,8 +1013,8 @@ int TScanContext::tokenizeIdentifier() case IIMAGEBUFFER: case UIMAGEBUFFER: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) return keyword; return firstGenerationImage(false); @@ -1059,8 +1037,8 @@ int TScanContext::tokenizeIdentifier() case IIMAGECUBEARRAY: case UIMAGECUBEARRAY: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) return keyword; return secondGenerationImage(); @@ -1078,7 +1056,7 @@ int TScanContext::tokenizeIdentifier() case DVEC3: case DVEC4: afterType = true; - if (parseContext.profile == EEsProfile || parseContext.version < 400) + if (_parseContext.profile == EEsProfile || _parseContext.version < 400) reservedWord(); return keyword; @@ -1091,11 +1069,11 @@ int TScanContext::tokenizeIdentifier() case U64VEC3: case U64VEC4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile != EEsProfile && parseContext.version >= 450 && - (parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int64)))) + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && + (_parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int64)))) return keyword; return identifierOrType(); @@ -1108,10 +1086,10 @@ int TScanContext::tokenizeIdentifier() case U8VEC3: case U8VEC4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int8)) && - parseContext.profile != EEsProfile && parseContext.version >= 450)) + if (_parseContext.symbolTable.atBuiltInLevel() || + ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int8)) && + _parseContext.profile != EEsProfile && _parseContext.version >= 450)) return keyword; return identifierOrType(); @@ -1124,14 +1102,14 @@ int TScanContext::tokenizeIdentifier() case U16VEC3: case U16VEC4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile != EEsProfile && parseContext.version >= 450 && + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && ( #ifdef AMD_EXTENSIONS - parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) || + _parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) || #endif - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int16)))) + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int16)))) return keyword; return identifierOrType(); case INT32_T: @@ -1143,10 +1121,10 @@ int TScanContext::tokenizeIdentifier() case U32VEC3: case U32VEC4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int32)) && - parseContext.profile != EEsProfile && parseContext.version >= 450)) + if (_parseContext.symbolTable.atBuiltInLevel() || + ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_int32)) && + _parseContext.profile != EEsProfile && _parseContext.version >= 450)) return keyword; return identifierOrType(); case FLOAT32_T: @@ -1166,10 +1144,10 @@ int TScanContext::tokenizeIdentifier() case F32MAT4X3: case F32MAT4X4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float32)) && - parseContext.profile != EEsProfile && parseContext.version >= 450)) + if (_parseContext.symbolTable.atBuiltInLevel() || + ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float32)) && + _parseContext.profile != EEsProfile && _parseContext.version >= 450)) return keyword; return identifierOrType(); @@ -1190,10 +1168,10 @@ int TScanContext::tokenizeIdentifier() case F64MAT4X3: case F64MAT4X4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - ((parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float64)) && - parseContext.profile != EEsProfile && parseContext.version >= 450)) + if (_parseContext.symbolTable.atBuiltInLevel() || + ((_parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float64)) && + _parseContext.profile != EEsProfile && _parseContext.version >= 450)) return keyword; return identifierOrType(); @@ -1214,14 +1192,14 @@ int TScanContext::tokenizeIdentifier() case F16MAT4X3: case F16MAT4X4: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile != EEsProfile && parseContext.version >= 450 && + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && ( #ifdef AMD_EXTENSIONS - parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) || + _parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) || #endif - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || - parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float16)))) + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types) || + _parseContext.extensionTurnedOn(E_GL_KHX_shader_explicit_arithmetic_types_float16)))) return keyword; return identifierOrType(); @@ -1231,10 +1209,10 @@ int TScanContext::tokenizeIdentifier() case ISAMPLERCUBEARRAY: case USAMPLERCUBEARRAY: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array)) return keyword; - if (parseContext.profile == EEsProfile || (parseContext.version < 400 && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_cube_map_array))) + if (_parseContext.profile == EEsProfile || (_parseContext.version < 400 && ! _parseContext.extensionTurnedOn(E_GL_ARB_texture_cube_map_array))) reservedWord(); return keyword; @@ -1271,16 +1249,16 @@ int TScanContext::tokenizeIdentifier() case SAMPLERBUFFER: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) return keyword; return es30ReservedFromGLSL(130); case ISAMPLERBUFFER: case USAMPLERBUFFER: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer)) return keyword; return es30ReservedFromGLSL(140); @@ -1288,7 +1266,7 @@ int TScanContext::tokenizeIdentifier() case ISAMPLER2DMS: case USAMPLER2DMS: afterType = true; - if (parseContext.profile == EEsProfile && parseContext.version >= 310) + if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) return keyword; return es30ReservedFromGLSL(150); @@ -1296,30 +1274,30 @@ int TScanContext::tokenizeIdentifier() case ISAMPLER2DMSARRAY: case USAMPLER2DMSARRAY: afterType = true; - if ((parseContext.profile == EEsProfile && parseContext.version >= 320) || - parseContext.extensionsTurnedOn(1, &E_GL_OES_texture_storage_multisample_2d_array)) + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 320) || + _parseContext.extensionsTurnedOn(1, &E_GL_OES_texture_storage_multisample_2d_array)) return keyword; return es30ReservedFromGLSL(150); case SAMPLER1D: case SAMPLER1DSHADOW: afterType = true; - if (parseContext.profile == EEsProfile) + if (_parseContext.profile == EEsProfile) reservedWord(); return keyword; case SAMPLER3D: afterType = true; - if (parseContext.profile == EEsProfile && parseContext.version < 300) { - if (!parseContext.extensionTurnedOn(E_GL_OES_texture_3D)) + if (_parseContext.profile == EEsProfile && _parseContext.version < 300) { + if (!_parseContext.extensionTurnedOn(E_GL_OES_texture_3D)) reservedWord(); } return keyword; case SAMPLER2DSHADOW: afterType = true; - if (parseContext.profile == EEsProfile && parseContext.version < 300) { - if (!parseContext.extensionTurnedOn(E_GL_EXT_shadow_samplers)) + if (_parseContext.profile == EEsProfile && _parseContext.version < 300) { + if (!_parseContext.extensionTurnedOn(E_GL_EXT_shadow_samplers)) reservedWord(); } return keyword; @@ -1327,11 +1305,11 @@ int TScanContext::tokenizeIdentifier() case SAMPLER2DRECT: case SAMPLER2DRECTSHADOW: afterType = true; - if (parseContext.profile == EEsProfile) + if (_parseContext.profile == EEsProfile) reservedWord(); - else if (parseContext.version < 140 && ! parseContext.symbolTable.atBuiltInLevel() && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_rectangle)) { - if (parseContext.relaxedErrors()) - parseContext.requireExtensions(loc, 1, &E_GL_ARB_texture_rectangle, "texture-rectangle sampler keyword"); + else if (_parseContext.version < 140 && ! _parseContext.symbolTable.atBuiltInLevel() && ! _parseContext.extensionTurnedOn(E_GL_ARB_texture_rectangle)) { + if (_parseContext.relaxedErrors()) + _parseContext.requireExtensions(loc, 1, &E_GL_ARB_texture_rectangle, "texture-rectangle sampler keyword"); else reservedWord(); } @@ -1339,18 +1317,18 @@ int TScanContext::tokenizeIdentifier() case SAMPLER1DARRAY: afterType = true; - if (parseContext.profile == EEsProfile && parseContext.version == 300) + if (_parseContext.profile == EEsProfile && _parseContext.version == 300) reservedWord(); - else if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 130)) + else if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 130)) return identifierOrType(); return keyword; case SAMPLEREXTERNALOES: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external) || - parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external_essl3)) + if (_parseContext.symbolTable.atBuiltInLevel() || + _parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external) || + _parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external_essl3)) return keyword; return identifierOrType(); @@ -1389,7 +1367,7 @@ int TScanContext::tokenizeIdentifier() case TEXTURE1DARRAY: case SAMPLER: case SAMPLERSHADOW: - if (parseContext.spvVersion.vulkan > 0) + if (_parseContext.spvVersion.vulkan > 0) return keyword; else return identifierOrType(); @@ -1400,7 +1378,7 @@ int TScanContext::tokenizeIdentifier() case ISUBPASSINPUTMS: case USUBPASSINPUT: case USUBPASSINPUTMS: - if (parseContext.spvVersion.vulkan > 0) + if (_parseContext.spvVersion.vulkan > 0) return keyword; else return identifierOrType(); @@ -1452,83 +1430,83 @@ int TScanContext::tokenizeIdentifier() case F16SUBPASSINPUT: case F16SUBPASSINPUTMS: afterType = true; - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) && - parseContext.profile != EEsProfile && parseContext.version >= 450)) + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) && + _parseContext.profile != EEsProfile && _parseContext.version >= 450)) return keyword; return identifierOrType(); #endif case NOPERSPECTIVE: #ifdef NV_EXTENSIONS - if (parseContext.profile == EEsProfile && parseContext.version >= 300 && - parseContext.extensionTurnedOn(E_GL_NV_shader_noperspective_interpolation)) + if (_parseContext.profile == EEsProfile && _parseContext.version >= 300 && + _parseContext.extensionTurnedOn(E_GL_NV_shader_noperspective_interpolation)) return keyword; #endif return es30ReservedFromGLSL(130); case SMOOTH: - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 130)) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 130)) return identifierOrType(); return keyword; #ifdef AMD_EXTENSIONS case __EXPLICITINTERPAMD: - if (parseContext.profile != EEsProfile && parseContext.version >= 450 && - parseContext.extensionTurnedOn(E_GL_AMD_shader_explicit_vertex_parameter)) + if (_parseContext.profile != EEsProfile && _parseContext.version >= 450 && + _parseContext.extensionTurnedOn(E_GL_AMD_shader_explicit_vertex_parameter)) return keyword; return identifierOrType(); #endif case FLAT: - if (parseContext.profile == EEsProfile && parseContext.version < 300) + if (_parseContext.profile == EEsProfile && _parseContext.version < 300) reservedWord(); - else if (parseContext.profile != EEsProfile && parseContext.version < 130) + else if (_parseContext.profile != EEsProfile && _parseContext.version < 130) return identifierOrType(); return keyword; case CENTROID: - if (parseContext.version < 120) + if (_parseContext.version < 120) return identifierOrType(); return keyword; case PRECISE: - if ((parseContext.profile == EEsProfile && - (parseContext.version >= 320 || parseContext.extensionsTurnedOn(Num_AEP_gpu_shader5, AEP_gpu_shader5))) || - (parseContext.profile != EEsProfile && parseContext.version >= 400)) + if ((_parseContext.profile == EEsProfile && + (_parseContext.version >= 320 || _parseContext.extensionsTurnedOn(Num_AEP_gpu_shader5, AEP_gpu_shader5))) || + (_parseContext.profile != EEsProfile && _parseContext.version >= 400)) return keyword; - if (parseContext.profile == EEsProfile && parseContext.version == 310) { + if (_parseContext.profile == EEsProfile && _parseContext.version == 310) { reservedWord(); return keyword; } return identifierOrType(); case INVARIANT: - if (parseContext.profile != EEsProfile && parseContext.version < 120) + if (_parseContext.profile != EEsProfile && _parseContext.version < 120) return identifierOrType(); return keyword; case PACKED: - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < 330)) + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < 330)) return reservedWord(); return identifierOrType(); case RESOURCE: { - bool reserved = (parseContext.profile == EEsProfile && parseContext.version >= 300) || - (parseContext.profile != EEsProfile && parseContext.version >= 420); + bool reserved = (_parseContext.profile == EEsProfile && _parseContext.version >= 300) || + (_parseContext.profile != EEsProfile && _parseContext.version >= 420); return identifierOrReserved(reserved); } case SUPERP: { - bool reserved = parseContext.profile == EEsProfile || parseContext.version >= 130; + bool reserved = _parseContext.profile == EEsProfile || _parseContext.version >= 130; return identifierOrReserved(reserved); } default: - parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); + _parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); return 0; } } @@ -1539,7 +1517,7 @@ int TScanContext::identifierOrType() if (field) return IDENTIFIER; - parserToken->sType.lex.symbol = parseContext.symbolTable.find(*parserToken->sType.lex.string); + parserToken->sType.lex.symbol = _parseContext.symbolTable.find(*parserToken->sType.lex.string); if ((afterType == false && afterStruct == false) && parserToken->sType.lex.symbol != nullptr) { if (const TVariable* variable = parserToken->sType.lex.symbol->getAsVariable()) { if (variable->isUserType()) { @@ -1558,8 +1536,8 @@ int TScanContext::identifierOrType() // extension support before the extension is enabled. int TScanContext::reservedWord() { - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.error(loc, "Reserved word.", tokenText, "", ""); + if (! _parseContext.symbolTable.atBuiltInLevel()) + _parseContext.error(loc, "Reserved word.", tokenText, "", ""); return 0; } @@ -1572,8 +1550,8 @@ int TScanContext::identifierOrReserved(bool reserved) return 0; } - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future reserved keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future reserved keyword", tokenText, ""); return identifierOrType(); } @@ -1582,16 +1560,16 @@ int TScanContext::identifierOrReserved(bool reserved) // but then got reserved by ES 3.0. int TScanContext::es30ReservedFromGLSL(int version) { - if (parseContext.symbolTable.atBuiltInLevel()) + if (_parseContext.symbolTable.atBuiltInLevel()) return keyword; - if ((parseContext.profile == EEsProfile && parseContext.version < 300) || - (parseContext.profile != EEsProfile && parseContext.version < version)) { - if (parseContext.forwardCompatible) - parseContext.warn(loc, "future reserved word in ES 300 and keyword in GLSL", tokenText, ""); + if ((_parseContext.profile == EEsProfile && _parseContext.version < 300) || + (_parseContext.profile != EEsProfile && _parseContext.version < version)) { + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "future reserved word in ES 300 and keyword in GLSL", tokenText, ""); return identifierOrType(); - } else if (parseContext.profile == EEsProfile && parseContext.version >= 300) + } else if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) reservedWord(); return keyword; @@ -1601,10 +1579,10 @@ int TScanContext::es30ReservedFromGLSL(int version) // showed up, both in an es version and a non-ES version. int TScanContext::nonreservedKeyword(int esVersion, int nonEsVersion) { - if ((parseContext.profile == EEsProfile && parseContext.version < esVersion) || - (parseContext.profile != EEsProfile && parseContext.version < nonEsVersion)) { - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future keyword", tokenText, ""); + if ((_parseContext.profile == EEsProfile && _parseContext.version < esVersion) || + (_parseContext.profile != EEsProfile && _parseContext.version < nonEsVersion)) { + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future keyword", tokenText, ""); return identifierOrType(); } @@ -1614,11 +1592,11 @@ int TScanContext::nonreservedKeyword(int esVersion, int nonEsVersion) int TScanContext::precisionKeyword() { - if (parseContext.profile == EEsProfile || parseContext.version >= 130) + if (_parseContext.profile == EEsProfile || _parseContext.version >= 130) return keyword; - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using ES precision qualifier keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using ES precision qualifier keyword", tokenText, ""); return identifierOrType(); } @@ -1627,11 +1605,11 @@ int TScanContext::matNxM() { afterType = true; - if (parseContext.version > 110) + if (_parseContext.version > 110) return keyword; - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future non-square matrix type keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future non-square matrix type keyword", tokenText, ""); return identifierOrType(); } @@ -1640,56 +1618,56 @@ int TScanContext::dMat() { afterType = true; - if (parseContext.profile == EEsProfile && parseContext.version >= 300) { + if (_parseContext.profile == EEsProfile && _parseContext.version >= 300) { reservedWord(); return keyword; } - if (parseContext.profile != EEsProfile && parseContext.version >= 400) + if (_parseContext.profile != EEsProfile && _parseContext.version >= 400) return keyword; - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future type keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future type keyword", tokenText, ""); return identifierOrType(); } int TScanContext::firstGenerationImage(bool inEs310) { - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile != EEsProfile && (parseContext.version >= 420 || - parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))) || - (inEs310 && parseContext.profile == EEsProfile && parseContext.version >= 310)) + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile != EEsProfile && (_parseContext.version >= 420 || + _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))) || + (inEs310 && _parseContext.profile == EEsProfile && _parseContext.version >= 310)) return keyword; - if ((parseContext.profile == EEsProfile && parseContext.version >= 300) || - (parseContext.profile != EEsProfile && parseContext.version >= 130)) { + if ((_parseContext.profile == EEsProfile && _parseContext.version >= 300) || + (_parseContext.profile != EEsProfile && _parseContext.version >= 130)) { reservedWord(); return keyword; } - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future type keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future type keyword", tokenText, ""); return identifierOrType(); } int TScanContext::secondGenerationImage() { - if (parseContext.profile == EEsProfile && parseContext.version >= 310) { + if (_parseContext.profile == EEsProfile && _parseContext.version >= 310) { reservedWord(); return keyword; } - if (parseContext.symbolTable.atBuiltInLevel() || - (parseContext.profile != EEsProfile && - (parseContext.version >= 420 || parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) + if (_parseContext.symbolTable.atBuiltInLevel() || + (_parseContext.profile != EEsProfile && + (_parseContext.version >= 420 || _parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store)))) return keyword; - if (parseContext.forwardCompatible) - parseContext.warn(loc, "using future type keyword", tokenText, ""); + if (_parseContext.forwardCompatible) + _parseContext.warn(loc, "using future type keyword", tokenText, ""); return identifierOrType(); } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h b/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h index 0cc7ea0a9e..39e7761a62 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h +++ b/deps/glslang/glslang/glslang/MachineIndependent/ScanContext.h @@ -33,6 +33,9 @@ // POSSIBILITY OF SUCH DAMAGE. // +#ifndef _MACHINE_INDEPENDENT_SCAN_CONTEXT_H +#define _MACHINE_INDEPENDENT_SCAN_CONTEXT_H + // // This holds context specific to the GLSL scanner, which // sits between the preprocessor scanner and parser. @@ -51,7 +54,7 @@ class TParserToken; class TScanContext { public: explicit TScanContext(TParseContextBase& pc) : - parseContext(pc), + _parseContext(pc), afterType(false), afterStruct(false), field(false) { } virtual ~TScanContext() { } @@ -77,7 +80,7 @@ protected: int firstGenerationImage(bool inEs310); int secondGenerationImage(); - TParseContextBase& parseContext; + TParseContextBase& _parseContext; bool afterType; // true if we've recognized a type, so can only be looking for an identifier bool afterStruct; // true if we've recognized the STRUCT keyword, so can only be looking for an identifier bool field; // true if we're on a field, right after a '.' @@ -90,3 +93,5 @@ protected: }; } // end namespace glslang + +#endif diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp index 4f39f3453e..7a3061821d 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp @@ -233,15 +233,15 @@ bool InitializeSymbolTable(const TString& builtIns, int version, EProfile profil intermediate.setSource(source); - std::unique_ptr parseContext(CreateParseContext(symbolTable, intermediate, version, profile, source, + std::unique_ptr _parseContext(CreateParseContext(symbolTable, intermediate, version, profile, source, language, infoSink, spvVersion, true, EShMsgDefault, true)); TShader::ForbidIncluder includer; - TPpContext ppContext(*parseContext, "", includer); - TScanContext scanContext(*parseContext); - parseContext->setScanContext(&scanContext); - parseContext->setPpContext(&ppContext); + TPpContext ppContext(*_parseContext, "", includer); + TScanContext scanContext(*_parseContext); + _parseContext->setScanContext(&scanContext); + _parseContext->setPpContext(&ppContext); // // Push the symbol table to give it an initial scope. This @@ -260,7 +260,7 @@ bool InitializeSymbolTable(const TString& builtIns, int version, EProfile profil return true; TInputScanner input(1, builtInShaders, builtInLengths); - if (! parseContext->parseShaderStrings(ppContext, input) != 0) { + if (! _parseContext->parseShaderStrings(ppContext, input) != 0) { infoSink.info.message(EPrefixInternalError, "Unable to parse built-ins"); printf("Unable to parse built-ins\n%s\n", infoSink.info.c_str()); printf("%s\n", builtInShaders[0]); @@ -696,7 +696,7 @@ void RecordProcesses(TIntermediate& intermediate, EShMessages messages, const st // This is the common setup and cleanup code for PreprocessDeferred and // CompileDeferred. // It takes any callable with a signature of -// bool (TParseContextBase& parseContext, TPpContext& ppContext, +// bool (TParseContextBase& _parseContext, TPpContext& ppContext, // TInputScanner& input, bool versionWillBeError, // TSymbolTable& , TIntermediate& , // EShOptimizationLevel , EShMessages ); @@ -849,31 +849,31 @@ bool ProcessDeferred( // Now we can process the full shader under proper symbols and rules. // - std::unique_ptr parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source, + std::unique_ptr _parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source, stage, compiler->infoSink, spvVersion, forwardCompatible, messages, false, sourceEntryPointName)); - TPpContext ppContext(*parseContext, names[numPre] ? names[numPre] : "", includer); + TPpContext ppContext(*_parseContext, names[numPre] ? names[numPre] : "", includer); // only GLSL (bison triggered, really) needs an externally set scan context - glslang::TScanContext scanContext(*parseContext); + glslang::TScanContext scanContext(*_parseContext); if (source == EShSourceGlsl) - parseContext->setScanContext(&scanContext); + _parseContext->setScanContext(&scanContext); - parseContext->setPpContext(&ppContext); - parseContext->setLimits(*resources); + _parseContext->setPpContext(&ppContext); + _parseContext->setLimits(*resources); if (! goodVersion) - parseContext->addError(); + _parseContext->addError(); if (warnVersionNotFirst) { TSourceLoc loc; loc.init(); - parseContext->warn(loc, "Illegal to have non-comment, non-whitespace tokens before #version", "#version", ""); + _parseContext->warn(loc, "Illegal to have non-comment, non-whitespace tokens before #version", "#version", ""); } - parseContext->initializeExtensionBehavior(); + _parseContext->initializeExtensionBehavior(); // Fill in the strings as outlined above. std::string preamble; - parseContext->getPreamble(preamble); + _parseContext->getPreamble(preamble); strings[0] = preamble.c_str(); lengths[0] = strlen(strings[0]); names[0] = nullptr; @@ -892,7 +892,7 @@ bool ProcessDeferred( // Push a new symbol allocation scope that will get used for the shader's globals. symbolTable->push(); - bool success = processingContext(*parseContext, ppContext, fullInput, + bool success = processingContext(*_parseContext, ppContext, fullInput, versionWillBeError, *symbolTable, intermediate, optLevel, messages); return success; @@ -967,7 +967,7 @@ private: // It places the result in the "string" argument to its constructor. struct DoPreprocessing { explicit DoPreprocessing(std::string* string): outputString(string) {} - bool operator()(TParseContextBase& parseContext, TPpContext& ppContext, + bool operator()(TParseContextBase& _parseContext, TPpContext& ppContext, TInputScanner& input, bool versionWillBeError, TSymbolTable&, TIntermediate&, EShOptimizationLevel, EShMessages) @@ -977,14 +977,14 @@ struct DoPreprocessing { static const std::string noSpaceBeforeTokens = ","; glslang::TPpToken ppToken; - parseContext.setScanner(&input); + _parseContext.setScanner(&input); ppContext.setInput(input, versionWillBeError); std::string outputBuffer; SourceLineSynchronizer lineSync( std::bind(&TInputScanner::getLastValidSourceIndex, &input), &outputBuffer); - parseContext.setExtensionCallback([&lineSync, &outputBuffer]( + _parseContext.setExtensionCallback([&lineSync, &outputBuffer]( int line, const char* extension, const char* behavior) { lineSync.syncToLine(line); outputBuffer += "#extension "; @@ -993,7 +993,7 @@ struct DoPreprocessing { outputBuffer += behavior; }); - parseContext.setLineCallback([&lineSync, &outputBuffer, &parseContext]( + _parseContext.setLineCallback([&lineSync, &outputBuffer, &_parseContext]( int curLineNum, int newLineNum, bool hasSource, int sourceNum, const char* sourceName) { // SourceNum is the number of the source-string that is being parsed. lineSync.syncToLine(curLineNum); @@ -1009,7 +1009,7 @@ struct DoPreprocessing { outputBuffer += std::to_string(sourceNum); } } - if (parseContext.lineDirectiveShouldSetNextLine()) { + if (_parseContext.lineDirectiveShouldSetNextLine()) { // newLineNum is the new line number for the line following the #line // directive. So the new line number for the current line is newLineNum -= 1; @@ -1019,7 +1019,7 @@ struct DoPreprocessing { lineSync.setLineNum(newLineNum + 1); }); - parseContext.setVersionCallback( + _parseContext.setVersionCallback( [&lineSync, &outputBuffer](int line, int version, const char* str) { lineSync.syncToLine(line); outputBuffer += "#version "; @@ -1030,7 +1030,7 @@ struct DoPreprocessing { } }); - parseContext.setPragmaCallback([&lineSync, &outputBuffer]( + _parseContext.setPragmaCallback([&lineSync, &outputBuffer]( int line, const glslang::TVector& ops) { lineSync.syncToLine(line); outputBuffer += "#pragma "; @@ -1039,7 +1039,7 @@ struct DoPreprocessing { } }); - parseContext.setErrorCallback([&lineSync, &outputBuffer]( + _parseContext.setErrorCallback([&lineSync, &outputBuffer]( int line, const char* errorMessage) { lineSync.syncToLine(line); outputBuffer += "#error "; @@ -1078,10 +1078,10 @@ struct DoPreprocessing { *outputString = std::move(outputBuffer); bool success = true; - if (parseContext.getNumErrors() > 0) { + if (_parseContext.getNumErrors() > 0) { success = false; - parseContext.infoSink.info.prefix(EPrefixError); - parseContext.infoSink.info << parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; + _parseContext.infoSink.info.prefix(EPrefixError); + _parseContext.infoSink.info << _parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; } return success; } @@ -1091,28 +1091,28 @@ struct DoPreprocessing { // DoFullParse is a valid ProcessingConext template argument for fully // parsing the shader. It populates the "intermediate" with the AST. struct DoFullParse{ - bool operator()(TParseContextBase& parseContext, TPpContext& ppContext, + bool operator()(TParseContextBase& _parseContext, TPpContext& ppContext, TInputScanner& fullInput, bool versionWillBeError, TSymbolTable&, TIntermediate& intermediate, EShOptimizationLevel optLevel, EShMessages messages) { bool success = true; // Parse the full shader. - if (! parseContext.parseShaderStrings(ppContext, fullInput, versionWillBeError)) + if (! _parseContext.parseShaderStrings(ppContext, fullInput, versionWillBeError)) success = false; if (success && intermediate.getTreeRoot()) { if (optLevel == EShOptNoGeneration) - parseContext.infoSink.info.message(EPrefixNone, "No errors. No code generation or linking was requested."); + _parseContext.infoSink.info.message(EPrefixNone, "No errors. No code generation or linking was requested."); else - success = intermediate.postProcess(intermediate.getTreeRoot(), parseContext.getLanguage()); + success = intermediate.postProcess(intermediate.getTreeRoot(), _parseContext.getLanguage()); } else if (! success) { - parseContext.infoSink.info.prefix(EPrefixError); - parseContext.infoSink.info << parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; + _parseContext.infoSink.info.prefix(EPrefixError); + _parseContext.infoSink.info << _parseContext.getNumErrors() << " compilation errors. No code generated.\n\n"; } if (messages & EShMsgAST) - intermediate.output(parseContext.infoSink, true); + intermediate.output(_parseContext.infoSink, true); return success; } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Compare.h b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Compare.h new file mode 100644 index 0000000000..92d288c08d --- /dev/null +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Compare.h @@ -0,0 +1,32 @@ +#ifndef _MACHINE_INDEPENDENT_COMPARE_H +#define _MACHINE_INDEPENDENT_COMPARE_H + +#include "../../../hlsl/hlslTokens.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; + } + }; +}; + +#endif diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp index 8048fa513d..6a2ab91904 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp @@ -99,12 +99,12 @@ int TPpContext::CPPdefine(TPpToken* ppToken) // get the macro name int token = scanToken(ppToken); if (token != PpAtomIdentifier) { - parseContext.ppError(ppToken->loc, "must be followed by macro name", "#define", ""); + _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#define", ""); return token; } if (ppToken->loc.string >= 0) { // We are in user code; check for reserved name use: - parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#define"); + _parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#define"); } // save the macro name @@ -119,7 +119,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) if (mac.args.size() == 0 && token == ')') break; if (token != PpAtomIdentifier) { - parseContext.ppError(ppToken->loc, "bad argument", "#define", ""); + _parseContext.ppError(ppToken->loc, "bad argument", "#define", ""); return token; } @@ -130,7 +130,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) bool duplicate = false; for (size_t a = 0; a < mac.args.size(); ++a) { if (mac.args[a] == argAtom) { - parseContext.ppError(ppToken->loc, "duplicate macro parameter", "#define", ""); + _parseContext.ppError(ppToken->loc, "duplicate macro parameter", "#define", ""); duplicate = true; break; } @@ -140,7 +140,7 @@ int TPpContext::CPPdefine(TPpToken* ppToken) token = scanToken(ppToken); } while (token == ','); if (token != ')') { - parseContext.ppError(ppToken->loc, "missing parenthesis", "#define", ""); + _parseContext.ppError(ppToken->loc, "missing parenthesis", "#define", ""); return token; } @@ -165,10 +165,10 @@ int TPpContext::CPPdefine(TPpToken* ppToken) // "Two replacement lists are identical if and only if the preprocessing tokens in both have the same number, // ordering, spelling, and white-space separation, where all white-space separations are considered identical." if (existing->args.size() != mac.args.size() || existing->emptyArgs != mac.emptyArgs) - parseContext.ppError(defineLoc, "Macro redefined; different number of arguments:", "#define", atomStrings.getString(defAtom)); + _parseContext.ppError(defineLoc, "Macro redefined; different number of arguments:", "#define", atomStrings.getString(defAtom)); else { if (existing->args != mac.args) - parseContext.ppError(defineLoc, "Macro redefined; different argument names:", "#define", atomStrings.getString(defAtom)); + _parseContext.ppError(defineLoc, "Macro redefined; different argument names:", "#define", atomStrings.getString(defAtom)); existing->body.reset(); mac.body.reset(); int newToken; @@ -176,10 +176,10 @@ int TPpContext::CPPdefine(TPpToken* ppToken) int oldToken; TPpToken oldPpToken; TPpToken newPpToken; - oldToken = existing->body.getToken(parseContext, &oldPpToken); - newToken = mac.body.getToken(parseContext, &newPpToken); + oldToken = existing->body.getToken(_parseContext, &oldPpToken); + newToken = mac.body.getToken(_parseContext, &newPpToken); if (oldToken != newToken || oldPpToken != newPpToken) { - parseContext.ppError(defineLoc, "Macro redefined; different substitutions:", "#define", atomStrings.getString(defAtom)); + _parseContext.ppError(defineLoc, "Macro redefined; different substitutions:", "#define", atomStrings.getString(defAtom)); break; } } while (newToken > 0); @@ -197,19 +197,19 @@ int TPpContext::CPPundef(TPpToken* ppToken) { int token = scanToken(ppToken); if (token != PpAtomIdentifier) { - parseContext.ppError(ppToken->loc, "must be followed by macro name", "#undef", ""); + _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#undef", ""); return token; } - parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#undef"); + _parseContext.reservedPpErrorCheck(ppToken->loc, ppToken->name, "#undef"); MacroSymbol* macro = lookupMacroDef(atomStrings.getAtom(ppToken->name)); if (macro != nullptr) macro->undef = 1; token = scanToken(ppToken); if (token != '\n') - parseContext.ppError(ppToken->loc, "can only be followed by a single macro name", "#undef", ""); + _parseContext.ppError(ppToken->loc, "can only be followed by a single macro name", "#undef", ""); return token; } @@ -243,7 +243,7 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) if (nextAtom == PpAtomIf || nextAtom == PpAtomIfdef || nextAtom == PpAtomIfndef) { depth++; if (ifdepth >= maxIfNesting || elsetracker >= maxIfNesting) { - parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if/#ifdef/#ifndef", ""); + _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if/#ifdef/#ifndef", ""); return EndOfInput; } else { ifdepth++; @@ -269,7 +269,7 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) break; } else if (nextAtom == PpAtomElif) { if (elseSeen[elsetracker]) - parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); /* we decrement ifdepth here, because CPPif will increment * it and we really want to leave it alone */ if (ifdepth > 0) { @@ -282,13 +282,13 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken) } } else if (nextAtom == PpAtomElse) { if (elseSeen[elsetracker]) - parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); + _parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); else elseSeen[elsetracker] = true; token = extraTokenCheck(nextAtom, ppToken, scanToken(ppToken)); } else if (nextAtom == PpAtomElif) { if (elseSeen[elsetracker]) - parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); } } @@ -315,10 +315,10 @@ int TPpContext::extraTokenCheck(int contextAtom, TPpToken* ppToken, int token) else label = ""; - if (parseContext.relaxedErrors()) - parseContext.ppWarn(ppToken->loc, message, label, ""); + if (_parseContext.relaxedErrors()) + _parseContext.ppWarn(ppToken->loc, message, label, ""); else - parseContext.ppError(ppToken->loc, message, label, ""); + _parseContext.ppError(ppToken->loc, message, label, ""); while (token != '\n' && token != EndOfInput) token = scanToken(ppToken); @@ -399,12 +399,12 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo TSourceLoc loc = ppToken->loc; // because we sometimes read the newline before reporting the error if (token == PpAtomIdentifier) { if (strcmp("defined", ppToken->name) == 0) { - if (! parseContext.isReadingHLSL() && isMacroInput()) { - if (parseContext.relaxedErrors()) - parseContext.ppWarn(ppToken->loc, "nonportable when expanded from macros for preprocessor expression", + if (! _parseContext.isReadingHLSL() && isMacroInput()) { + if (_parseContext.relaxedErrors()) + _parseContext.ppWarn(ppToken->loc, "nonportable when expanded from macros for preprocessor expression", "defined", ""); else - parseContext.ppError(ppToken->loc, "cannot use in preprocessor expression when expanded from macros", + _parseContext.ppError(ppToken->loc, "cannot use in preprocessor expression when expanded from macros", "defined", ""); } bool needclose = 0; @@ -414,7 +414,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo token = scanToken(ppToken); } if (token != PpAtomIdentifier) { - parseContext.ppError(loc, "incorrect directive, expected identifier", "preprocessor evaluation", ""); + _parseContext.ppError(loc, "incorrect directive, expected identifier", "preprocessor evaluation", ""); err = true; res = 0; @@ -426,7 +426,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo token = scanToken(ppToken); if (needclose) { if (token != ')') { - parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); + _parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); err = true; res = 0; @@ -446,7 +446,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo token = eval(token, MIN_PRECEDENCE, shortCircuit, res, err, ppToken); if (! err) { if (token != ')') { - parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); + _parseContext.ppError(loc, "expected ')'", "preprocessor evaluation", ""); err = true; res = 0; @@ -465,7 +465,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo token = eval(token, UNARY, shortCircuit, res, err, ppToken); res = unop[op].op(res); } else { - parseContext.ppError(loc, "bad expression", "preprocessor evaluation", ""); + _parseContext.ppError(loc, "bad expression", "preprocessor evaluation", ""); err = true; res = 0; @@ -501,7 +501,7 @@ int TPpContext::eval(int token, int precedence, bool shortCircuit, int& res, boo if (binop[op].op == op_div || binop[op].op == op_mod) { if (res == 0) { - parseContext.ppError(loc, "division by 0", "preprocessor evaluation", ""); + _parseContext.ppError(loc, "division by 0", "preprocessor evaluation", ""); res = 1; } } @@ -517,19 +517,19 @@ int TPpContext::evalToToken(int token, bool shortCircuit, int& res, bool& err, T while (token == PpAtomIdentifier && strcmp("defined", ppToken->name) != 0) { int macroReturn = MacroExpand(ppToken, true, false); if (macroReturn == 0) { - parseContext.ppError(ppToken->loc, "can't evaluate expression", "preprocessor evaluation", ""); + _parseContext.ppError(ppToken->loc, "can't evaluate expression", "preprocessor evaluation", ""); err = true; res = 0; token = scanToken(ppToken); break; } if (macroReturn == -1) { - if (! shortCircuit && parseContext.profile == EEsProfile) { + if (! shortCircuit && _parseContext.profile == EEsProfile) { const char* message = "undefined macro in expression not allowed in es profile"; - if (parseContext.relaxedErrors()) - parseContext.ppWarn(ppToken->loc, message, "preprocessor evaluation", ppToken->name); + if (_parseContext.relaxedErrors()) + _parseContext.ppWarn(ppToken->loc, message, "preprocessor evaluation", ppToken->name); else - parseContext.ppError(ppToken->loc, message, "preprocessor evaluation", ppToken->name); + _parseContext.ppError(ppToken->loc, message, "preprocessor evaluation", ppToken->name); } } token = scanToken(ppToken); @@ -543,7 +543,7 @@ int TPpContext::CPPif(TPpToken* ppToken) { int token = scanToken(ppToken); if (ifdepth >= maxIfNesting || elsetracker >= maxIfNesting) { - parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if", ""); + _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#if", ""); return EndOfInput; } else { elsetracker++; @@ -564,7 +564,7 @@ int TPpContext::CPPifdef(int defined, TPpToken* ppToken) { int token = scanToken(ppToken); if (ifdepth > maxIfNesting || elsetracker > maxIfNesting) { - parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#ifdef", ""); + _parseContext.ppError(ppToken->loc, "maximum nesting depth exceeded", "#ifdef", ""); return EndOfInput; } else { elsetracker++; @@ -573,14 +573,14 @@ int TPpContext::CPPifdef(int defined, TPpToken* ppToken) if (token != PpAtomIdentifier) { if (defined) - parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifdef", ""); + _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifdef", ""); else - parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifndef", ""); + _parseContext.ppError(ppToken->loc, "must be followed by macro name", "#ifndef", ""); } else { MacroSymbol* macro = lookupMacroDef(atomStrings.getAtom(ppToken->name)); token = scanToken(ppToken); if (token != '\n') { - parseContext.ppError(ppToken->loc, "unexpected tokens following #ifdef directive - expected a newline", "#ifdef", ""); + _parseContext.ppError(ppToken->loc, "unexpected tokens following #ifdef directive - expected a newline", "#ifdef", ""); while (token != '\n' && token != EndOfInput) token = scanToken(ppToken); } @@ -607,7 +607,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) // otherwise ppToken already has the header name and it was "header-name" style if (token != PpAtomConstString) { - parseContext.ppError(directiveLoc, "must be followed by a header name", "#include", ""); + _parseContext.ppError(directiveLoc, "must be followed by a header name", "#include", ""); return token; } @@ -618,9 +618,9 @@ int TPpContext::CPPinclude(TPpToken* ppToken) token = scanToken(ppToken); if (token != '\n') { if (token == EndOfInput) - parseContext.ppError(ppToken->loc, "expected newline after header name:", "#include", "%s", filename.c_str()); + _parseContext.ppError(ppToken->loc, "expected newline after header name:", "#include", "%s", filename.c_str()); else - parseContext.ppError(ppToken->loc, "extra content after header name:", "#include", "%s", filename.c_str()); + _parseContext.ppError(ppToken->loc, "extra content after header name:", "#include", "%s", filename.c_str()); return token; } @@ -640,7 +640,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) if (res != nullptr && !res->headerName.empty()) { if (res->headerData != nullptr && res->headerLength > 0) { // path for processing one or more tokens from an included header, hand off 'res' - const bool forNextLine = parseContext.lineDirectiveShouldSetNextLine(); + const bool forNextLine = _parseContext.lineDirectiveShouldSetNextLine(); std::ostringstream prologue; std::ostringstream epilogue; prologue << "#line " << forNextLine << " " << "\"" << res->headerName << "\"\n"; @@ -648,7 +648,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) "#line " << directiveLoc.line + forNextLine << " " << directiveLoc.getStringNameOrNum() << "\n"; pushInput(new TokenizableIncludeFile(directiveLoc, prologue.str(), res, epilogue.str(), this)); // There's no "current" location anymore. - parseContext.setCurrentColumn(0); + _parseContext.setCurrentColumn(0); } else { // things are okay, but there is nothing to process includer.releaseInclude(res); @@ -658,7 +658,7 @@ int TPpContext::CPPinclude(TPpToken* ppToken) std::string message = res != nullptr ? std::string(res->headerData, res->headerLength) : std::string("Could not process include directive"); - parseContext.ppError(directiveLoc, message.c_str(), "#include", "for header name: %s", filename.c_str()); + _parseContext.ppError(directiveLoc, message.c_str(), "#include", "for header name: %s", filename.c_str()); includer.releaseInclude(res); } @@ -675,7 +675,7 @@ int TPpContext::CPPline(TPpToken* ppToken) int token = scanToken(ppToken); const TSourceLoc directiveLoc = ppToken->loc; if (token == '\n') { - parseContext.ppError(ppToken->loc, "must by followed by an integral literal", "#line", ""); + _parseContext.ppError(ppToken->loc, "must by followed by an integral literal", "#line", ""); return token; } @@ -692,31 +692,31 @@ int TPpContext::CPPline(TPpToken* ppToken) if (token == '\n') ++lineRes; - if (parseContext.lineDirectiveShouldSetNextLine()) + if (_parseContext.lineDirectiveShouldSetNextLine()) --lineRes; - parseContext.setCurrentLine(lineRes); + _parseContext.setCurrentLine(lineRes); if (token != '\n') { if (token == PpAtomConstString) { - parseContext.ppRequireExtensions(directiveLoc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based #line"); + _parseContext.ppRequireExtensions(directiveLoc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based #line"); // We need to save a copy of the string instead of pointing // to the name field of the token since the name field // will likely be overwritten by the next token scan. sourceName = atomStrings.getString(atomStrings.getAddAtom(ppToken->name)); - parseContext.setCurrentSourceName(sourceName); + _parseContext.setCurrentSourceName(sourceName); hasFile = true; token = scanToken(ppToken); } else { token = eval(token, MIN_PRECEDENCE, false, fileRes, fileErr, ppToken); if (! fileErr) { - parseContext.setCurrentString(fileRes); + _parseContext.setCurrentString(fileRes); hasFile = true; } } } } if (!fileErr && !lineErr) { - parseContext.notifyLineDirective(directiveLoc.line, lineToken, hasFile, fileRes, sourceName); + _parseContext.notifyLineDirective(directiveLoc.line, lineToken, hasFile, fileRes, sourceName); } token = extraTokenCheck(PpAtomLine, ppToken, token); @@ -745,9 +745,9 @@ int TPpContext::CPPerror(TPpToken* ppToken) message.append(" "); token = scanToken(ppToken); } - parseContext.notifyErrorDirective(loc.line, message.c_str()); + _parseContext.notifyErrorDirective(loc.line, message.c_str()); // store this msg into the shader's information log..set the Compile Error flag!!!! - parseContext.ppError(loc, message.c_str(), "#error", ""); + _parseContext.ppError(loc, message.c_str(), "#error", ""); return '\n'; } @@ -785,9 +785,9 @@ int TPpContext::CPPpragma(TPpToken* ppToken) } if (token == EndOfInput) - parseContext.ppError(loc, "directive must end with a newline", "#pragma", ""); + _parseContext.ppError(loc, "directive must end with a newline", "#pragma", ""); else - parseContext.handlePragma(loc, tokens); + _parseContext.handlePragma(loc, tokens); return token; } @@ -798,21 +798,21 @@ int TPpContext::CPPversion(TPpToken* ppToken) int token = scanToken(ppToken); if (errorOnVersion || versionSeen) { - if (parseContext.isReadingHLSL()) - parseContext.ppError(ppToken->loc, "invalid preprocessor command", "#version", ""); + if (_parseContext.isReadingHLSL()) + _parseContext.ppError(ppToken->loc, "invalid preprocessor command", "#version", ""); else - parseContext.ppError(ppToken->loc, "must occur first in shader", "#version", ""); + _parseContext.ppError(ppToken->loc, "must occur first in shader", "#version", ""); } versionSeen = true; if (token == '\n') { - parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); + _parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); return token; } if (token != PpAtomConstInt) - parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); + _parseContext.ppError(ppToken->loc, "must be followed by version number", "#version", ""); ppToken->ival = atoi(ppToken->name); int versionNumber = ppToken->ival; @@ -820,21 +820,21 @@ int TPpContext::CPPversion(TPpToken* ppToken) token = scanToken(ppToken); if (token == '\n') { - parseContext.notifyVersion(line, versionNumber, nullptr); + _parseContext.notifyVersion(line, versionNumber, nullptr); return token; } else { int profileAtom = atomStrings.getAtom(ppToken->name); if (profileAtom != PpAtomCore && profileAtom != PpAtomCompatibility && profileAtom != PpAtomEs) - parseContext.ppError(ppToken->loc, "bad profile name; use es, core, or compatibility", "#version", ""); - parseContext.notifyVersion(line, versionNumber, ppToken->name); + _parseContext.ppError(ppToken->loc, "bad profile name; use es, core, or compatibility", "#version", ""); + _parseContext.notifyVersion(line, versionNumber, ppToken->name); token = scanToken(ppToken); if (token == '\n') return token; else - parseContext.ppError(ppToken->loc, "bad tokens following profile -- expected newline", "#version", ""); + _parseContext.ppError(ppToken->loc, "bad tokens following profile -- expected newline", "#version", ""); } return token; @@ -848,36 +848,36 @@ int TPpContext::CPPextension(TPpToken* ppToken) char extensionName[MaxTokenLength + 1]; if (token=='\n') { - parseContext.ppError(ppToken->loc, "extension name not specified", "#extension", ""); + _parseContext.ppError(ppToken->loc, "extension name not specified", "#extension", ""); return token; } if (token != PpAtomIdentifier) - parseContext.ppError(ppToken->loc, "extension name expected", "#extension", ""); + _parseContext.ppError(ppToken->loc, "extension name expected", "#extension", ""); assert(strlen(ppToken->name) <= MaxTokenLength); strcpy(extensionName, ppToken->name); token = scanToken(ppToken); if (token != ':') { - parseContext.ppError(ppToken->loc, "':' missing after extension name", "#extension", ""); + _parseContext.ppError(ppToken->loc, "':' missing after extension name", "#extension", ""); return token; } token = scanToken(ppToken); if (token != PpAtomIdentifier) { - parseContext.ppError(ppToken->loc, "behavior for extension not specified", "#extension", ""); + _parseContext.ppError(ppToken->loc, "behavior for extension not specified", "#extension", ""); return token; } - parseContext.updateExtensionBehavior(line, extensionName, ppToken->name); - parseContext.notifyExtensionDirective(line, extensionName, ppToken->name); + _parseContext.updateExtensionBehavior(line, extensionName, ppToken->name); + _parseContext.notifyExtensionDirective(line, extensionName, ppToken->name); token = scanToken(ppToken); if (token == '\n') return token; else - parseContext.ppError(ppToken->loc, "extra tokens -- expected newline", "#extension",""); + _parseContext.ppError(ppToken->loc, "extra tokens -- expected newline", "#extension",""); return token; } @@ -893,18 +893,18 @@ int TPpContext::readCPPline(TPpToken* ppToken) break; case PpAtomElse: if (elseSeen[elsetracker]) - parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); + _parseContext.ppError(ppToken->loc, "#else after #else", "#else", ""); elseSeen[elsetracker] = true; if (ifdepth == 0) - parseContext.ppError(ppToken->loc, "mismatched statements", "#else", ""); + _parseContext.ppError(ppToken->loc, "mismatched statements", "#else", ""); token = extraTokenCheck(PpAtomElse, ppToken, scanToken(ppToken)); token = CPPelse(0, ppToken); break; case PpAtomElif: if (ifdepth == 0) - parseContext.ppError(ppToken->loc, "mismatched statements", "#elif", ""); + _parseContext.ppError(ppToken->loc, "mismatched statements", "#elif", ""); if (elseSeen[elsetracker]) - parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); + _parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", ""); // this token is really a dont care, but we still need to eat the tokens token = scanToken(ppToken); while (token != '\n' && token != EndOfInput) @@ -913,7 +913,7 @@ int TPpContext::readCPPline(TPpToken* ppToken) break; case PpAtomEndif: if (ifdepth == 0) - parseContext.ppError(ppToken->loc, "mismatched statements", "#endif", ""); + _parseContext.ppError(ppToken->loc, "mismatched statements", "#endif", ""); else { elseSeen[elsetracker] = false; --elsetracker; @@ -931,8 +931,8 @@ int TPpContext::readCPPline(TPpToken* ppToken) token = CPPifdef(0, ppToken); break; case PpAtomInclude: - if(!parseContext.isReadingHLSL()) { - parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_include_directive, "#include"); + if(!_parseContext.isReadingHLSL()) { + _parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_include_directive, "#include"); } token = CPPinclude(ppToken); break; @@ -955,11 +955,11 @@ int TPpContext::readCPPline(TPpToken* ppToken) token = CPPextension(ppToken); break; default: - parseContext.ppError(ppToken->loc, "invalid directive:", "#", ppToken->name); + _parseContext.ppError(ppToken->loc, "invalid directive:", "#", ppToken->name); break; } } else if (token != '\n' && token != EndOfInput) - parseContext.ppError(ppToken->loc, "invalid directive", "#", ""); + _parseContext.ppError(ppToken->loc, "invalid directive", "#", ""); while (token != '\n' && token != EndOfInput) token = scanToken(ppToken); @@ -986,7 +986,7 @@ int TPpContext::scanHeaderName(TPpToken* ppToken, char delimit) if (ch == delimit) { ppToken->name[len] = '\0'; if (tooLong) - parseContext.ppError(ppToken->loc, "header name too long", "", ""); + _parseContext.ppError(ppToken->loc, "header name too long", "", ""); return PpAtomConstString; } else if (ch == EndOfInput) return EndOfInput; @@ -1038,7 +1038,7 @@ int TPpContext::tMacroInput::scan(TPpToken* ppToken) { int token; do { - token = mac->body.getToken(pp->parseContext, ppToken); + token = mac->body.getToken(pp->_parseContext, ppToken); } while (token == ' '); // handle white space in macro // Hash operators basically turn off a round of macro substitution @@ -1075,7 +1075,7 @@ int TPpContext::tMacroInput::scan(TPpToken* ppToken) } // HLSL does expand macros before concatenation - if (pasting && pp->parseContext.isReadingHLSL()) + if (pasting && pp->_parseContext.isReadingHLSL()) pasting = false; // TODO: preprocessor: properly handle whitespace (or lack of it) between tokens when expanding @@ -1128,22 +1128,22 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka int macroAtom = atomStrings.getAtom(ppToken->name); switch (macroAtom) { case PpAtomLineMacro: - ppToken->ival = parseContext.getCurrentLoc().line; + ppToken->ival = _parseContext.getCurrentLoc().line; snprintf(ppToken->name, sizeof(ppToken->name), "%d", ppToken->ival); UngetToken(PpAtomConstInt, ppToken); return 1; case PpAtomFileMacro: { - if (parseContext.getCurrentLoc().name) - parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based __FILE__"); - ppToken->ival = parseContext.getCurrentLoc().string; + if (_parseContext.getCurrentLoc().name) + _parseContext.ppRequireExtensions(ppToken->loc, 1, &E_GL_GOOGLE_cpp_style_line_directive, "filename-based __FILE__"); + ppToken->ival = _parseContext.getCurrentLoc().string; snprintf(ppToken->name, sizeof(ppToken->name), "%s", ppToken->loc.getStringNameOrNum().c_str()); UngetToken(PpAtomConstInt, ppToken); return 1; } case PpAtomVersionMacro: - ppToken->ival = parseContext.version; + ppToken->ival = _parseContext.version; snprintf(ppToken->name, sizeof(ppToken->name), "%d", ppToken->ival); UngetToken(PpAtomConstInt, ppToken); return 1; @@ -1197,20 +1197,20 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka while (1) { token = scanToken(ppToken); if (token == EndOfInput || token == tMarkerInput::marker) { - parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); delete in; return 0; } if (token == '\n') { if (! newLineOkay) { - parseContext.ppError(loc, "End of line in macro substitution:", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(loc, "End of line in macro substitution:", "macro expansion", atomStrings.getString(macroAtom)); delete in; return 0; } continue; } if (token == '#') { - parseContext.ppError(ppToken->loc, "unexpected '#'", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(ppToken->loc, "unexpected '#'", "macro expansion", atomStrings.getString(macroAtom)); delete in; return 0; } @@ -1235,7 +1235,7 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka } while (arg < in->mac->args.size()); if (arg < in->mac->args.size()) - parseContext.ppError(loc, "Too few args in Macro", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(loc, "Too few args in Macro", "macro expansion", atomStrings.getString(macroAtom)); else if (token != ')') { depth=0; while (token != EndOfInput && (depth > 0 || token != ')')) { @@ -1247,11 +1247,11 @@ int TPpContext::MacroExpand(TPpToken* ppToken, bool expandUndef, bool newLineOka } if (token == EndOfInput) { - parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(loc, "End of input in macro", "macro expansion", atomStrings.getString(macroAtom)); delete in; return 0; } - parseContext.ppError(loc, "Too many args in macro", "macro expansion", atomStrings.getString(macroAtom)); + _parseContext.ppError(loc, "Too many args in macro", "macro expansion", atomStrings.getString(macroAtom)); } // We need both expanded and non-expanded forms of the argument, for whether or diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp index c89b37688a..83c9d7e8e1 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp @@ -84,7 +84,7 @@ NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace glslang { TPpContext::TPpContext(TParseContextBase& pc, const std::string& rootFileName, TShader::Includer& inclr) : - preamble(0), strings(0), previous_token('\n'), parseContext(pc), includer(inclr), inComment(false), + preamble(0), strings(0), previous_token('\n'), _parseContext(pc), includer(inclr), inComment(false), rootFileName(rootFileName), currentSourceFile(rootFileName) { diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h index b3a39c5cbc..6324923d75 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.h @@ -291,7 +291,7 @@ protected: // Scanner data: int previous_token; - TParseContextBase& parseContext; + TParseContextBase& _parseContext; // Get the next token from *stack* of input sources, popping input sources // that are out of tokens, down until an input source is found that has a token. @@ -411,7 +411,7 @@ protected: class tTokenInput : public tInput { public: tTokenInput(TPpContext* pp, TokenStream* t, bool prepasting) : tInput(pp), tokens(t), lastTokenPastes(prepasting) { } - virtual int scan(TPpToken *ppToken) override { return tokens->getToken(pp->parseContext, ppToken); } + virtual int scan(TPpToken *ppToken) override { return tokens->getToken(pp->_parseContext, ppToken); } virtual int getch() override { assert(0); return EndOfInput; } virtual void ungetch() override { assert(0); } virtual bool peekPasting() override { return tokens->peekTokenizedPasting(lastTokenPastes); } @@ -450,7 +450,7 @@ protected: // Move past escaped newlines, as many as sequentially exist do { if (input->peek() == '\r' || input->peek() == '\n') { - bool allowed = pp->parseContext.lineContinuationCheck(input->getSourceLoc(), pp->inComment); + bool allowed = pp->_parseContext.lineContinuationCheck(input->getSourceLoc(), pp->inComment); if (! allowed && pp->inComment) return '\\'; @@ -553,14 +553,14 @@ protected: void notifyActivated() override { - prevScanner = pp->parseContext.getScanner(); - pp->parseContext.setScanner(&scanner); + prevScanner = pp->_parseContext.getScanner(); + pp->_parseContext.setScanner(&scanner); pp->push_include(includedFile_); } void notifyDeleted() override { - pp->parseContext.setScanner(prevScanner); + pp->_parseContext.setScanner(prevScanner); pp->pop_include(); } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp index 0c620a5f5b..c73d74178d 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp @@ -134,18 +134,18 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) int firstDecimal = len; // 1.#INF or -1.#INF - if (ch == '#' && (ifdepth > 0 || parseContext.intermediate.getSource() == EShSourceHlsl)) { + if (ch == '#' && (ifdepth > 0 || _parseContext.intermediate.getSource() == EShSourceHlsl)) { if ((len < 2) || (len == 2 && ppToken->name[0] != '1') || (len == 3 && ppToken->name[1] != '1' && !(ppToken->name[0] == '-' || ppToken->name[0] == '+')) || (len > 3)) - parseContext.ppError(ppToken->loc, "unexpected use of", "#", ""); + _parseContext.ppError(ppToken->loc, "unexpected use of", "#", ""); else { // we have 1.# or -1.# or +1.#, check for 'INF' if ((ch = getChar()) != 'I' || (ch = getChar()) != 'N' || (ch = getChar()) != 'F') - parseContext.ppError(ppToken->loc, "expected 'INF'", "#", ""); + _parseContext.ppError(ppToken->loc, "expected 'INF'", "#", ""); else { // we have [+-].#INF, and we are targeting IEEE 754, so wrap it up: saveName('I'); @@ -213,7 +213,7 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) ch = getChar(); } } else { - parseContext.ppError(ppToken->loc, "bad character in float exponent", "", ""); + _parseContext.ppError(ppToken->loc, "bad character in float exponent", "", ""); } } @@ -249,11 +249,11 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) bool isDouble = false; bool isFloat16 = false; if (ch == 'l' || ch == 'L') { - if (ifdepth == 0 && parseContext.intermediate.getSource() == EShSourceGlsl) - parseContext.doubleCheck(ppToken->loc, "double floating-point suffix"); + if (ifdepth == 0 && _parseContext.intermediate.getSource() == EShSourceGlsl) + _parseContext.doubleCheck(ppToken->loc, "double floating-point suffix"); if (ifdepth == 0 && !hasDecimalOrExponent) - parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); - if (parseContext.intermediate.getSource() == EShSourceGlsl) { + _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); + if (_parseContext.intermediate.getSource() == EShSourceGlsl) { int ch2 = getChar(); if (ch2 != 'f' && ch2 != 'F') { ungetChar(); @@ -263,16 +263,16 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) saveName(ch2); isDouble = true; } - } else if (parseContext.intermediate.getSource() == EShSourceHlsl) { + } else if (_parseContext.intermediate.getSource() == EShSourceHlsl) { saveName(ch); isDouble = true; } } else if (ch == 'h' || ch == 'H') { - if (ifdepth == 0 && parseContext.intermediate.getSource() == EShSourceGlsl) - parseContext.float16Check(ppToken->loc, "half floating-point suffix"); + if (ifdepth == 0 && _parseContext.intermediate.getSource() == EShSourceGlsl) + _parseContext.float16Check(ppToken->loc, "half floating-point suffix"); if (ifdepth == 0 && !hasDecimalOrExponent) - parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); - if (parseContext.intermediate.getSource() == EShSourceGlsl) { + _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); + if (_parseContext.intermediate.getSource() == EShSourceGlsl) { int ch2 = getChar(); if (ch2 != 'f' && ch2 != 'F') { ungetChar(); @@ -282,17 +282,17 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) saveName(ch2); isFloat16 = true; } - } else if (parseContext.intermediate.getSource() == EShSourceHlsl) { + } else if (_parseContext.intermediate.getSource() == EShSourceHlsl) { saveName(ch); isFloat16 = true; } } else if (ch == 'f' || ch == 'F') { if (ifdepth == 0) - parseContext.profileRequires(ppToken->loc, EEsProfile, 300, nullptr, "floating-point suffix"); - if (ifdepth == 0 && !parseContext.relaxedErrors()) - parseContext.profileRequires(ppToken->loc, ~EEsProfile, 120, nullptr, "floating-point suffix"); + _parseContext.profileRequires(ppToken->loc, EEsProfile, 300, nullptr, "floating-point suffix"); + if (ifdepth == 0 && !_parseContext.relaxedErrors()) + _parseContext.profileRequires(ppToken->loc, ~EEsProfile, 120, nullptr, "floating-point suffix"); if (ifdepth == 0 && !hasDecimalOrExponent) - parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); + _parseContext.ppError(ppToken->loc, "float literal needs a decimal point or exponent", "", ""); saveName(ch); } else ungetChar(); @@ -301,7 +301,7 @@ int TPpContext::lFloatConst(int len, int ch, TPpToken* ppToken) if (len > MaxTokenLength) { len = MaxTokenLength; - parseContext.ppError(ppToken->loc, "float literal too long", "", ""); + _parseContext.ppError(ppToken->loc, "float literal too long", "", ""); } ppToken->name[len] = '\0'; @@ -349,7 +349,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) ppToken->name[0] = 0; ppToken->ival = 0; - if (parseContext.intermediate.getSource() != EShSourceHlsl) { + if (_parseContext.intermediate.getSource() != EShSourceHlsl) { // illegal, except in macro definition, for which case we report the character return '\''; } @@ -358,7 +358,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) switch (ch) { case '\'': // As empty sequence: '' - parseContext.ppError(ppToken->loc, "unexpected", "\'", ""); + _parseContext.ppError(ppToken->loc, "unexpected", "\'", ""); return PpAtomConstInt; case '\\': // As escape sequence: '\XXX' @@ -386,7 +386,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) break; case 'x': case '0': - parseContext.ppError(ppToken->loc, "octal and hex sequences not supported", "\\", ""); + _parseContext.ppError(ppToken->loc, "octal and hex sequences not supported", "\\", ""); break; default: // This catches '\'', '\"', '\?', etc. @@ -404,7 +404,7 @@ int TPpContext::characterLiteral(TPpToken* ppToken) ppToken->name[1] = '\0'; ch = getChar(); if (ch != '\'') { - parseContext.ppError(ppToken->loc, "expected", "\'", ""); + _parseContext.ppError(ppToken->loc, "expected", "\'", ""); // Look ahead for a closing ' do { ch = getChar(); @@ -452,7 +452,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ch = getch(); } - ppToken->loc = pp->parseContext.getCurrentLoc(); + ppToken->loc = pp->_parseContext.getCurrentLoc(); len = 0; switch (ch) { default: @@ -479,7 +479,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ch = getch(); } else { if (! AlreadyComplained) { - pp->parseContext.ppError(ppToken->loc, "name too long", "", ""); + pp->_parseContext.ppError(ppToken->loc, "name too long", "", ""); AlreadyComplained = 1; } ch = getch(); @@ -522,14 +522,14 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) } else if (ch >= 'a' && ch <= 'f') { ii = ch - 'a' + 10; } else - pp->parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); + pp->_parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); ival = (ival << 4) | ii; } else { if (! AlreadyComplained) { if(len < MaxTokenLength) - pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); + pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); else - pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too long", "", ""); + pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too long", "", ""); AlreadyComplained = 1; } ival = 0xffffffffffffffffull; @@ -539,7 +539,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')); } else { - pp->parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); + pp->_parseContext.ppError(ppToken->loc, "bad digit in hexadecimal literal", "", ""); } if (ch == 'u' || ch == 'U') { if (len < MaxTokenLength) @@ -557,7 +557,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) #ifdef AMD_EXTENSIONS nextCh = getch(); if ((nextCh == 's' || nextCh == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)nextCh; isInt16 = true; @@ -570,7 +570,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) isInt64 = true; #ifdef AMD_EXTENSIONS } else if ((ch == 's' || ch == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt16 = true; @@ -579,21 +579,21 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ungetch(); ppToken->name[len] = '\0'; - if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (pp->ifdepth == 0) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "64-bit hexadecimal literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int64_Extensions, Int64_Extensions, "64-bit hexadecimal literal"); } ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; } else if (isInt16) { if (pp->ifdepth == 0) { - if (pp->parseContext.intermediate.getSource() == EShSourceGlsl) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + if (pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "16-bit hexadecimal literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int16_Extensions, Int16_Extensions, "16-bit hexadecimal literal"); } } @@ -601,7 +601,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16; } else { if (ival > 0xffffffffu && !AlreadyComplained) - pp->parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); + pp->_parseContext.ppError(ppToken->loc, "hexadecimal literal too big", "", ""); ppToken->ival = (int)ival; return isUnsigned ? PpAtomConstUint : PpAtomConstInt; } @@ -620,7 +620,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; else if (! AlreadyComplained) { - pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); AlreadyComplained = 1; } if (ival <= 0x1fffffffffffffffull) { @@ -638,7 +638,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; else if (! AlreadyComplained) { - pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); AlreadyComplained = 1; } ch = getch(); @@ -649,7 +649,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) // wasn't a float, so must be octal... if (nonOctal) - pp->parseContext.ppError(ppToken->loc, "octal literal digit too large", "", ""); + pp->_parseContext.ppError(ppToken->loc, "octal literal digit too large", "", ""); if (ch == 'u' || ch == 'U') { if (len < MaxTokenLength) @@ -667,7 +667,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) #ifdef AMD_EXTENSIONS nextCh = getch(); if ((nextCh == 's' || nextCh == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)nextCh; isInt16 = true; @@ -680,7 +680,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) isInt64 = true; #ifdef AMD_EXTENSIONS } else if ((ch == 's' || ch == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt16 = true; @@ -693,23 +693,23 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) octalOverflow = true; if (octalOverflow) - pp->parseContext.ppError(ppToken->loc, "octal literal too big", "", ""); + pp->_parseContext.ppError(ppToken->loc, "octal literal too big", "", ""); - if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (pp->ifdepth == 0) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "64-bit octal literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int64_Extensions, Int64_Extensions, "64-bit octal literal"); } ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; } else if (isInt16) { if (pp->ifdepth == 0) { - if (pp->parseContext.intermediate.getSource() == EShSourceGlsl) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + if (pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "16-bit octal literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int16_Extensions, Int16_Extensions, "16-bit octal literal"); } } @@ -729,7 +729,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; else if (! AlreadyComplained) { - pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); + pp->_parseContext.ppError(ppToken->loc, "numeric literal too long", "", ""); AlreadyComplained = 1; } ch = getch(); @@ -758,7 +758,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) #ifdef AMD_EXTENSIONS nextCh = getch(); if ((nextCh == 's' || nextCh == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)nextCh; isInt16 = true; @@ -771,7 +771,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) isInt64 = true; #ifdef AMD_EXTENSIONS } else if ((ch == 's' || ch == 'S') && - pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; isInt16 = true; @@ -797,27 +797,27 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) else overflow = (ival > oneTenthMaxInt || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt)); if (overflow) { - pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); + pp->_parseContext.ppError(ppToken->loc, "numeric literal too big", "", ""); ival = 0xFFFFFFFFFFFFFFFFull; break; } else ival = ival * 10 + ch; } - if (isInt64 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { + if (isInt64 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (pp->ifdepth == 0) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "64-bit literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int64_Extensions, Int64_Extensions, "64-bit literal"); } ppToken->i64val = ival; return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64; } else if (isInt16) { - if (pp->ifdepth == 0 && pp->parseContext.intermediate.getSource() == EShSourceGlsl) { - pp->parseContext.requireProfile(ppToken->loc, ~EEsProfile, + if (pp->ifdepth == 0 && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { + pp->_parseContext.requireProfile(ppToken->loc, ~EEsProfile, "16-bit literal"); - pp->parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, + pp->_parseContext.profileRequires(ppToken->loc, ~EEsProfile, 0, Num_Int16_Extensions, Int16_Extensions, "16-bit literal"); } ppToken->ival = (int)ival; @@ -970,14 +970,14 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) do { while (ch != '*') { if (ch == EndOfInput) { - pp->parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); + pp->_parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); return ch; } ch = getch(); } ch = getch(); if (ch == EndOfInput) { - pp->parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); + pp->_parseContext.ppError(ppToken->loc, "End of input in comment", "comment", ""); return ch; } } while (ch != '/'); @@ -1009,7 +1009,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ppToken->name[len] = '\0'; if (ch != '"') { ungetch(); - pp->parseContext.ppError(ppToken->loc, "End of line in string", "string", ""); + pp->_parseContext.ppError(ppToken->loc, "End of line in string", "string", ""); } return PpAtomConstString; case ':': @@ -1051,7 +1051,7 @@ int TPpContext::tokenize(TPpToken& ppToken) } continue; } else { - parseContext.ppError(ppToken.loc, "preprocessor directive cannot be preceded by another token", "#", ""); + _parseContext.ppError(ppToken.loc, "preprocessor directive cannot be preceded by another token", "#", ""); return EndOfInput; } } @@ -1079,14 +1079,14 @@ int TPpContext::tokenize(TPpToken& ppToken) continue; break; case PpAtomConstString: - if (ifdepth == 0 && parseContext.intermediate.getSource() != EShSourceHlsl) { + if (ifdepth == 0 && _parseContext.intermediate.getSource() != EShSourceHlsl) { // HLSL allows string literals. - parseContext.ppError(ppToken.loc, "string literals not supported", "\"\"", ""); + _parseContext.ppError(ppToken.loc, "string literals not supported", "\"\"", ""); continue; } break; case '\'': - parseContext.ppError(ppToken.loc, "character literals not supported", "\'", ""); + _parseContext.ppError(ppToken.loc, "character literals not supported", "\'", ""); continue; default: strcpy(ppToken.name, atomStrings.getString(token)); @@ -1106,7 +1106,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) { // starting with ## is illegal, skip to next token if (token == PpAtomPaste) { - parseContext.ppError(ppToken.loc, "unexpected location", "##", ""); + _parseContext.ppError(ppToken.loc, "unexpected location", "##", ""); return scanToken(&ppToken); } @@ -1122,7 +1122,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) // This covers end of macro expansion if (endOfReplacementList()) { - parseContext.ppError(ppToken.loc, "unexpected location; end of replacement list", "##", ""); + _parseContext.ppError(ppToken.loc, "unexpected location; end of replacement list", "##", ""); break; } @@ -1131,7 +1131,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) // This covers end of argument expansion if (token == tMarkerInput::marker) { - parseContext.ppError(ppToken.loc, "unexpected location; end of argument", "##", ""); + _parseContext.ppError(ppToken.loc, "unexpected location; end of argument", "##", ""); break; } @@ -1162,13 +1162,13 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) strcpy(pastedPpToken.name, atomStrings.getString(token)); break; default: - parseContext.ppError(ppToken.loc, "not supported for these tokens", "##", ""); + _parseContext.ppError(ppToken.loc, "not supported for these tokens", "##", ""); return resultToken; } // combine the tokens if (strlen(ppToken.name) + strlen(pastedPpToken.name) > MaxTokenLength) { - parseContext.ppError(ppToken.loc, "combined tokens are too long", "##", ""); + _parseContext.ppError(ppToken.loc, "combined tokens are too long", "##", ""); return resultToken; } strncat(ppToken.name, pastedPpToken.name, MaxTokenLength - strlen(ppToken.name)); @@ -1179,7 +1179,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) if (newToken > 0) resultToken = newToken; else - parseContext.ppError(ppToken.loc, "combined token is invalid", "##", ""); + _parseContext.ppError(ppToken.loc, "combined token is invalid", "##", ""); } } @@ -1190,7 +1190,7 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) void TPpContext::missingEndifCheck() { if (ifdepth > 0) - parseContext.ppError(parseContext.getCurrentLoc(), "missing #endif", "", ""); + _parseContext.ppError(_parseContext.getCurrentLoc(), "missing #endif", "", ""); } } // end namespace glslang diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp index 7dc2722ce1..475d0aad3b 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp @@ -195,7 +195,7 @@ void TPpContext::TokenStream::putToken(int atom, TPpToken* ppToken) // Read the next token from a token stream. // (Not the source stream, but a stream used to hold a tokenized macro). -int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken *ppToken) +int TPpContext::TokenStream::getToken(TParseContextBase& _parseContext, TPpToken *ppToken) { // get the atom int atom = getSubtoken(); @@ -204,7 +204,7 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken // init the token ppToken->clear(); - ppToken->loc = parseContext.getCurrentLoc(); + ppToken->loc = _parseContext.getCurrentLoc(); // get the backing name string if (SaveName(atom)) { @@ -216,7 +216,7 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken len++; ch = getSubtoken(); } else { - parseContext.error(ppToken->loc, "token too long", "", ""); + _parseContext.error(ppToken->loc, "token too long", "", ""); break; } } @@ -227,8 +227,8 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken if (atom == '#') { if (current < data.size()) { if (getSubtoken() == '#') { - parseContext.requireProfile(ppToken->loc, ~EEsProfile, "token pasting (##)"); - parseContext.profileRequires(ppToken->loc, ~EEsProfile, 130, 0, "token pasting (##)"); + _parseContext.requireProfile(ppToken->loc, ~EEsProfile, "token pasting (##)"); + _parseContext.profileRequires(ppToken->loc, ~EEsProfile, 130, 0, "token pasting (##)"); atom = PpAtomPaste; } else ungetSubtoken(); diff --git a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp index 870840c56e..49c31492a1 100644 --- a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp +++ b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp @@ -34,6 +34,7 @@ #include "../osinclude.h" +#undef STRICT #define STRICT #define VC_EXTRALEAN 1 #include diff --git a/deps/glslang/glslang/hlsl/hlslGrammar.cpp b/deps/glslang/glslang/hlsl/hlslGrammar.cpp index cb05877917..aa05465abc 100755 --- a/deps/glslang/glslang/hlsl/hlslGrammar.cpp +++ b/deps/glslang/glslang/hlsl/hlslGrammar.cpp @@ -67,12 +67,12 @@ bool HlslGrammar::parse() void HlslGrammar::expected(const char* syntax) { - parseContext.error(token.loc, "Expected", syntax, ""); + _parseContext.error(token.loc, "Expected", syntax, ""); } void HlslGrammar::unimplemented(const char* error) { - parseContext.error(token.loc, "Unimplemented", error, ""); + _parseContext.error(token.loc, "Unimplemented", error, ""); } // IDENTIFIER @@ -195,7 +195,7 @@ bool HlslGrammar::acceptSamplerState() if (! acceptTokenClass(EHTokLeftBrace)) return true; - parseContext.warn(token.loc, "unimplemented", "immediate sampler state", ""); + _parseContext.warn(token.loc, "unimplemented", "immediate sampler state", ""); do { // read state name @@ -337,7 +337,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) expected("namespace name"); return false; } - parseContext.pushNamespace(*namespaceToken.string); + _parseContext.pushNamespace(*namespaceToken.string); if (!acceptTokenClass(EHTokLeftBrace)) { expected("{"); return false; @@ -350,7 +350,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) expected("}"); return false; } - parseContext.popNamespace(); + _parseContext.popNamespace(); return true; } @@ -391,16 +391,16 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) TIntermAggregate* initializers = nullptr; while (acceptIdentifier(idToken)) { TString *fullName = idToken.string; - if (parseContext.symbolTable.atGlobalLevel()) - parseContext.getFullNamespaceName(fullName); + if (_parseContext.symbolTable.atGlobalLevel()) + _parseContext.getFullNamespaceName(fullName); if (peekTokenClass(EHTokLeftParen)) { // looks like function parameters // merge in the attributes into the return type - parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true); + _parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true); // Potentially rename shader entry point function. No-op most of the time. - parseContext.renameShaderFunction(fullName); + _parseContext.renameShaderFunction(fullName); // function_parameters declarator.function = new TFunction(fullName, declaredType); @@ -416,24 +416,24 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) declarator.loc = token.loc; if (peekTokenClass(EHTokLeftBrace)) { if (declarator_list) - parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", ""); + _parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", ""); if (typedefDecl) - parseContext.error(idToken.loc, "function body can't be in a typedef", "{", ""); + _parseContext.error(idToken.loc, "function body can't be in a typedef", "{", ""); return acceptFunctionDefinition(declarator, nodeList, nullptr); } else { if (typedefDecl) - parseContext.error(idToken.loc, "function typedefs not implemented", "{", ""); - parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true); + _parseContext.error(idToken.loc, "function typedefs not implemented", "{", ""); + _parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true); } } else { // A variable declaration. // merge in the attributes, the first time around, into the shared type if (! declarator_list) - parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType); + _parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType); // Fix the storage qualifier if it's a global. - if (declaredType.getQualifier().storage == EvqTemporary && parseContext.symbolTable.atGlobalLevel()) + if (declaredType.getQualifier().storage == EvqTemporary && _parseContext.symbolTable.atGlobalLevel()) declaredType.getQualifier().storage = EvqUniform; // recognize array_specifier @@ -464,7 +464,7 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) TIntermTyped* expressionNode = nullptr; if (acceptTokenClass(EHTokAssign)) { if (typedefDecl) - parseContext.error(idToken.loc, "can't have an initializer", "typedef", ""); + _parseContext.error(idToken.loc, "can't have an initializer", "typedef", ""); if (! acceptAssignmentExpression(expressionNode)) { expected("initializer"); return false; @@ -473,24 +473,24 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList) // TODO: things scoped within an annotation need their own name space; // TODO: strings are not yet handled. - if (variableType.getBasicType() != EbtString && parseContext.getAnnotationNestingLevel() == 0) { + if (variableType.getBasicType() != EbtString && _parseContext.getAnnotationNestingLevel() == 0) { if (typedefDecl) - parseContext.declareTypedef(idToken.loc, *fullName, variableType); + _parseContext.declareTypedef(idToken.loc, *fullName, variableType); else if (variableType.getBasicType() == EbtBlock) { if (expressionNode) - parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", ""); - parseContext.declareBlock(idToken.loc, variableType, fullName); - parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName); + _parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", ""); + _parseContext.declareBlock(idToken.loc, variableType, fullName); + _parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName); } else { if (variableType.getQualifier().storage == EvqUniform && ! variableType.containsOpaque()) { // this isn't really an individual variable, but a member of the $Global buffer - parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName); + _parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName); } else { // Declare the variable and add any initializer code to the AST. // The top-level node is always made into an aggregate, as that's // historically how the AST has been. initializers = intermediate.growAggregate(initializers, - parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode), + _parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode), idToken.loc); } } @@ -544,7 +544,7 @@ bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node) return false; if (attributes.size() > 0) - parseContext.warn(token.loc, "attributes don't apply to control declaration", "", ""); + _parseContext.warn(token.loc, "attributes don't apply to control declaration", "", ""); // filter out type casts if (peekTokenClass(EHTokLeftParen)) { @@ -572,7 +572,7 @@ bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node) return false; } - node = parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode); + node = _parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode); return true; } @@ -608,16 +608,16 @@ bool HlslGrammar::acceptFullySpecifiedType(TType& type, TIntermNode*& nodeList, if (type.getBasicType() == EbtBlock) { // the type was a block, which set some parts of the qualifier - parseContext.mergeQualifiers(type.getQualifier(), qualifier); + _parseContext.mergeQualifiers(type.getQualifier(), qualifier); // merge in the attributes - parseContext.transferTypeAttributes(token.loc, attributes, type); + _parseContext.transferTypeAttributes(token.loc, attributes, type); // further, it can create an anonymous instance of the block // (cbuffer and tbuffer don't consume the next identifier, and // should set forbidDeclarators) if (forbidDeclarators || peek() != EHTokIdentifier) - parseContext.declareBlock(loc, type); + _parseContext.declareBlock(loc, type); } else { // Some qualifiers are set when parsing the type. Merge those with // whatever comes from acceptQualifier. @@ -651,7 +651,7 @@ bool HlslGrammar::acceptQualifier(TQualifier& qualifier) do { switch (peek()) { case EHTokStatic: - qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; + qualifier.storage = _parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; break; case EHTokExtern: // TODO: no meaning in glslang? @@ -719,27 +719,27 @@ bool HlslGrammar::acceptQualifier(TQualifier& qualifier) // for output variables. case EHTokPoint: qualifier.storage = EvqIn; - if (!parseContext.handleInputGeometry(token.loc, ElgPoints)) + if (!_parseContext.handleInputGeometry(token.loc, ElgPoints)) return false; break; case EHTokLine: qualifier.storage = EvqIn; - if (!parseContext.handleInputGeometry(token.loc, ElgLines)) + if (!_parseContext.handleInputGeometry(token.loc, ElgLines)) return false; break; case EHTokTriangle: qualifier.storage = EvqIn; - if (!parseContext.handleInputGeometry(token.loc, ElgTriangles)) + if (!_parseContext.handleInputGeometry(token.loc, ElgTriangles)) return false; break; case EHTokLineAdj: qualifier.storage = EvqIn; - if (!parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency)) + if (!_parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency)) return false; break; case EHTokTriangleAdj: qualifier.storage = EvqIn; - if (!parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency)) + if (!_parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency)) return false; break; @@ -781,9 +781,9 @@ bool HlslGrammar::acceptLayoutQualifierList(TQualifier& qualifier) expected("expression"); return false; } - parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr); + _parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr); } else - parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string); + _parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string); // COMMA if (! acceptTokenClass(EHTokComma)) @@ -1076,7 +1076,7 @@ bool HlslGrammar::acceptAnnotations(TQualifier&) return false; // note that we are nesting a name space - parseContext.nestAnnotations(); + _parseContext.nestAnnotations(); // declaration SEMI_COLON ... declaration SEMICOLON RIGHT_ANGLE do { @@ -1095,7 +1095,7 @@ bool HlslGrammar::acceptAnnotations(TQualifier&) } } while (true); - parseContext.unnestAnnotations(); + _parseContext.unnestAnnotations(); return true; } @@ -1154,7 +1154,7 @@ bool HlslGrammar::acceptSubpassInputType(TType& type) sampler.setSubpass(subpassBasicType, multisample); // Remember the declared return type. Function returns false on error. - if (!parseContext.setTextureReturnType(sampler, subpassType, token.loc)) + if (!_parseContext.setTextureReturnType(sampler, subpassType, token.loc)) return false; type.shallowCopy(TType(sampler, EvqUniform)); @@ -1327,7 +1327,7 @@ bool HlslGrammar::acceptTextureType(TType& type) // Buffer, RWBuffer and RWTexture (images) require a TLayoutFormat. We handle only a limit set. if (image || dim == EsdBuffer) - format = parseContext.getLayoutFromTxType(token.loc, txType); + format = _parseContext.getLayoutFromTxType(token.loc, txType); const TBasicType txBasicType = txType.isStruct() ? (*txType.getStruct())[0].type->getBasicType() : txType.getBasicType(); @@ -1345,7 +1345,7 @@ bool HlslGrammar::acceptTextureType(TType& type) } // Remember the declared return type. Function returns false on error. - if (!parseContext.setTextureReturnType(sampler, txType, token.loc)) + if (!_parseContext.setTextureReturnType(sampler, txType, token.loc)) return false; // Force uncombined, if necessary @@ -1369,7 +1369,7 @@ bool HlslGrammar::acceptType(TType& type) bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) { // Basic types for min* types, use native halfs if the option allows them. - bool enable16BitTypes = parseContext.hlslEnable16BitTypes(); + bool enable16BitTypes = _parseContext.hlslEnable16BitTypes(); const TBasicType min16float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat; const TBasicType min10float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat; @@ -1385,7 +1385,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) if (identifierString != nullptr) { TString name = identifierString; // if it's an identifier, it's not a type - if (parseContext.symbolTable.find(name) != nullptr) + if (_parseContext.symbolTable.find(name) != nullptr) return false; } } @@ -1424,7 +1424,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) if (! acceptStreamOutTemplateType(type, geometry)) return false; - if (! parseContext.handleOutputGeometry(token.loc, geometry)) + if (! _parseContext.handleOutputGeometry(token.loc, geometry)) return false; return true; @@ -1499,7 +1499,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) // An identifier could be for a user-defined type. // Note we cache the symbol table lookup, to save for a later rule // when this is not a type. - if (parseContext.lookupUserType(*token.string, type) != nullptr) { + if (_parseContext.lookupUserType(*token.string, type) != nullptr) { advanceToken(); return true; } else @@ -2006,7 +2006,7 @@ bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList) advanceToken(); if ((isUnorm || isSnorm) && !type.isFloatingDomain()) { - parseContext.error(token.loc, "unorm and snorm only valid in floating point domain", "", ""); + _parseContext.error(token.loc, "unorm and snorm only valid in floating point domain", "", ""); return false; } @@ -2068,7 +2068,7 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) // LEFT_BRACE, or // struct_type IDENTIFIER if (! acceptTokenClass(EHTokLeftBrace)) { - if (structName.size() > 0 && !postDeclsFound && parseContext.lookupUserType(structName, type) != nullptr) { + if (structName.size() > 0 && !postDeclsFound && _parseContext.lookupUserType(structName, type) != nullptr) { // struct_type IDENTIFIER return true; } else { @@ -2083,9 +2083,9 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) // Save each member function so they can be processed after we have a fully formed 'this'. TVector functionDeclarators; - parseContext.pushNamespace(structName); + _parseContext.pushNamespace(structName); bool acceptedList = acceptStructDeclarationList(typeList, nodeList, functionDeclarators); - parseContext.popNamespace(); + _parseContext.popNamespace(); if (! acceptedList) { expected("struct member declarations"); @@ -2107,7 +2107,7 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) new(&type) TType(typeList, structName, postDeclQualifier); // sets EbtBlock } - parseContext.declareStruct(token.loc, structName, type); + _parseContext.declareStruct(token.loc, structName, type); // For member functions: now that we know the type of 'this', go back and // - add their implicit argument with 'this' (not to the mangling, just the argument list) @@ -2120,8 +2120,8 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) // All member functions get parsed inside the class/struct namespace and with the // class/struct members in a symbol-table level. - parseContext.pushNamespace(structName); - parseContext.pushThisScope(type, functionDeclarators); + _parseContext.pushNamespace(structName); + _parseContext.pushThisScope(type, functionDeclarators); bool deferredSuccess = true; for (int b = 0; b < (int)functionDeclarators.size() && deferredSuccess; ++b) { // parse body @@ -2130,8 +2130,8 @@ bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList) deferredSuccess = false; popTokenStream(); } - parseContext.popThisScope(); - parseContext.popNamespace(); + _parseContext.popThisScope(); + _parseContext.popNamespace(); return deferredSuccess; } @@ -2172,7 +2172,7 @@ bool HlslGrammar::acceptConstantBufferType(TType& type) return true; } else { - parseContext.error(token.loc, "non-structure type in ConstantBuffer", "", ""); + _parseContext.error(token.loc, "non-structure type in ConstantBuffer", "", ""); return false; } } @@ -2307,7 +2307,7 @@ bool HlslGrammar::acceptStructBufferType(TType& type) // We may have created an equivalent type before, in which case we should use its // deep structure. - parseContext.shareStructBufferType(blockType); + _parseContext.shareStructBufferType(blockType); type.shallowCopy(blockType); @@ -2353,7 +2353,7 @@ bool HlslGrammar::acceptStructDeclarationList(TTypeList*& typeList, TIntermNode* } // merge in the attributes - parseContext.transferTypeAttributes(token.loc, attributes, memberType); + _parseContext.transferTypeAttributes(token.loc, attributes, memberType); // struct_declarator COMMA struct_declarator ... bool functionDefinitionAccepted = false; @@ -2392,7 +2392,7 @@ bool HlslGrammar::acceptStructDeclarationList(TTypeList*& typeList, TIntermNode* // EQUAL assignment_expression if (acceptTokenClass(EHTokAssign)) { - parseContext.warn(idToken.loc, "struct-member initializers ignored", "typedef", ""); + _parseContext.warn(idToken.loc, "struct-member initializers ignored", "typedef", ""); TIntermTyped* expressionNode = nullptr; if (! acceptAssignmentExpression(expressionNode)) { expected("initializer"); @@ -2436,7 +2436,7 @@ bool HlslGrammar::acceptMemberFunctionDefinition(TIntermNode*& nodeList, const T bool accepted = false; TString* functionName = &memberName; - parseContext.getFullNamespaceName(functionName); + _parseContext.getFullNamespaceName(functionName); declarator.function = new TFunction(functionName, type); if (type.getQualifier().storage == EvqTemporary) declarator.function->setImplicitThis(); @@ -2509,15 +2509,15 @@ bool HlslGrammar::acceptDefaultParameterDeclaration(const TType& type, TIntermTy // For initializer lists, we have to const-fold into a constructor for the type, so build // that. - TFunction* constructor = parseContext.makeConstructorCall(token.loc, type); + TFunction* constructor = _parseContext.makeConstructorCall(token.loc, type); if (constructor == nullptr) // cannot construct return false; TIntermTyped* arguments = nullptr; for (int i = 0; i < int(node->getAsAggregate()->getSequence().size()); i++) - parseContext.handleFunctionArgument(constructor, arguments, node->getAsAggregate()->getSequence()[i]->getAsTyped()); + _parseContext.handleFunctionArgument(constructor, arguments, node->getAsAggregate()->getSequence()[i]->getAsTyped()); - node = parseContext.handleFunctionCall(token.loc, constructor, node); + node = _parseContext.handleFunctionCall(token.loc, constructor, node); } if (node == nullptr) @@ -2535,7 +2535,7 @@ bool HlslGrammar::acceptDefaultParameterDeclaration(const TType& type, TIntermTy if (node != nullptr && origNode != node) return true; - parseContext.error(token.loc, "invalid default parameter value", "", ""); + _parseContext.error(token.loc, "invalid default parameter value", "", ""); return false; } @@ -2559,7 +2559,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) return false; // merge in the attributes - parseContext.transferTypeAttributes(token.loc, attributes, *type); + _parseContext.transferTypeAttributes(token.loc, attributes, *type); // identifier HlslToken idToken; @@ -2570,7 +2570,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) acceptArraySpecifier(arraySizes); if (arraySizes) { if (arraySizes->hasUnsized()) { - parseContext.error(token.loc, "function parameter requires array size", "[]", ""); + _parseContext.error(token.loc, "function parameter requires array size", "[]", ""); return false; } @@ -2584,11 +2584,11 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) if (!acceptDefaultParameterDeclaration(*type, defaultValue)) return false; - parseContext.paramFix(*type); + _parseContext.paramFix(*type); // If any prior parameters have default values, all the parameters after that must as well. if (defaultValue == nullptr && function.getDefaultParamCount() > 0) { - parseContext.error(idToken.loc, "invalid parameter after default value parameters", idToken.string->c_str(), ""); + _parseContext.error(idToken.loc, "invalid parameter after default value parameters", idToken.string->c_str(), ""); return false; } @@ -2607,7 +2607,7 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function) bool HlslGrammar::acceptFunctionDefinition(TFunctionDeclarator& declarator, TIntermNode*& nodeList, TVector* deferredTokens) { - parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, false /* not prototype */); + _parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, false /* not prototype */); if (deferredTokens) return captureBlockTokens(*deferredTokens); @@ -2621,7 +2621,7 @@ bool HlslGrammar::acceptFunctionBody(TFunctionDeclarator& declarator, TIntermNod TIntermNode* entryPointNode = nullptr; // This does a pushScope() - TIntermNode* functionNode = parseContext.handleFunctionDefinition(declarator.loc, *declarator.function, + TIntermNode* functionNode = _parseContext.handleFunctionDefinition(declarator.loc, *declarator.function, declarator.attributes, entryPointNode); // compound_statement @@ -2630,7 +2630,7 @@ bool HlslGrammar::acceptFunctionBody(TFunctionDeclarator& declarator, TIntermNod return false; // this does a popScope() - parseContext.handleFunctionBody(declarator.loc, *declarator.function, functionBody, functionNode); + _parseContext.handleFunctionBody(declarator.loc, *declarator.function, functionBody, functionNode); // Hook up the 1 or 2 function definitions. nodeList = intermediate.growAggregate(nodeList, functionNode); @@ -2817,11 +2817,11 @@ bool HlslGrammar::acceptAssignmentExpression(TIntermTyped*& node) return false; } - node = parseContext.handleAssign(loc, assignOp, node, rightNode); - node = parseContext.handleLvalue(loc, "assign", node); + node = _parseContext.handleAssign(loc, assignOp, node, rightNode); + node = _parseContext.handleLvalue(loc, "assign", node); if (node == nullptr) { - parseContext.error(loc, "could not create assignment", "", ""); + _parseContext.error(loc, "could not create assignment", "", ""); return false; } @@ -2848,11 +2848,11 @@ bool HlslGrammar::acceptConditionalExpression(TIntermTyped*& node) if (! acceptTokenClass(EHTokQuestion)) return true; - node = parseContext.convertConditionalExpression(token.loc, node, false); + node = _parseContext.convertConditionalExpression(token.loc, node, false); if (node == nullptr) return false; - ++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors + ++_parseContext.controlFlowNestingLevel; // this only needs to work right if no errors TIntermTyped* trueNode = nullptr; if (! acceptExpression(trueNode)) { @@ -2872,7 +2872,7 @@ bool HlslGrammar::acceptConditionalExpression(TIntermTyped*& node) return false; } - --parseContext.controlFlowNestingLevel; + --_parseContext.controlFlowNestingLevel; node = intermediate.addSelection(node, trueNode, falseNode, loc); @@ -2917,7 +2917,7 @@ bool HlslGrammar::acceptBinaryExpression(TIntermTyped*& node, PrecedenceLevel pr node = intermediate.addBinaryMath(op, node, rightNode, loc); if (node == nullptr) { - parseContext.error(loc, "Could not perform requested binary operation", "", ""); + _parseContext.error(loc, "Could not perform requested binary operation", "", ""); return false; } } while (true); @@ -2953,14 +2953,14 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) return false; // Hook it up like a constructor - TFunction* constructorFunction = parseContext.makeConstructorCall(loc, castType); + TFunction* constructorFunction = _parseContext.makeConstructorCall(loc, castType); if (constructorFunction == nullptr) { expected("type that can be constructed"); return false; } TIntermTyped* arguments = nullptr; - parseContext.handleFunctionArgument(constructorFunction, arguments, node); - node = parseContext.handleFunctionCall(loc, constructorFunction, arguments); + _parseContext.handleFunctionArgument(constructorFunction, arguments, node); + node = _parseContext.handleFunctionCall(loc, constructorFunction, arguments); return node != nullptr; } else { @@ -2972,7 +2972,7 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) // Note, there are no array constructors like // (float[2](...)) if (arraySizes != nullptr) - parseContext.error(loc, "parenthesized array constructor not allowed", "([]())", "", ""); + _parseContext.error(loc, "parenthesized array constructor not allowed", "([]())", "", ""); } } else { // This isn't a type cast, but it still started "(", so if it is a @@ -3004,7 +3004,7 @@ bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node) // These unary ops require lvalues if (unaryOp == EOpPreIncrement || unaryOp == EOpPreDecrement) - node = parseContext.handleLvalue(loc, "unary operator", node); + node = _parseContext.handleLvalue(loc, "unary operator", node); return node != nullptr; } @@ -3052,7 +3052,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) while (acceptTokenClass(EHTokColonColon)) { // user-type or namespace name fullName = NewPoolTString(fullName->c_str()); - fullName->append(parseContext.scopeMangler); + fullName->append(_parseContext.scopeMangler); if (acceptIdentifier(idToken)) fullName->append(*idToken.string); else { @@ -3061,7 +3061,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) } } if (! peekTokenClass(EHTokLeftParen)) { - node = parseContext.handleVariable(idToken.loc, fullName); + node = _parseContext.handleVariable(idToken.loc, fullName); if (node == nullptr) return false; } else if (acceptFunctionCall(idToken.loc, *fullName, node, nullptr)) { @@ -3116,7 +3116,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) return false; } } else - node = parseContext.handleDotDereference(field.loc, node, *field.string); + node = _parseContext.handleDotDereference(field.loc, node, *field.string); break; } @@ -3130,7 +3130,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) return false; } advanceToken(); - node = parseContext.handleBracketDereference(indexNode->getLoc(), node, indexNode); + node = _parseContext.handleBracketDereference(indexNode->getLoc(), node, indexNode); if (node == nullptr) return false; break; @@ -3141,7 +3141,7 @@ bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node) case EOpPostDecrement: // DEC_OP node = intermediate.addUnaryMath(postOp, node, loc); - node = parseContext.handleLvalue(loc, "unary operator", node); + node = _parseContext.handleLvalue(loc, "unary operator", node); break; default: assert(0); @@ -3158,7 +3158,7 @@ bool HlslGrammar::acceptConstructor(TIntermTyped*& node) // type TType type; if (acceptType(type)) { - TFunction* constructorFunction = parseContext.makeConstructorCall(token.loc, type); + TFunction* constructorFunction = _parseContext.makeConstructorCall(token.loc, type); if (constructorFunction == nullptr) return false; @@ -3172,7 +3172,7 @@ bool HlslGrammar::acceptConstructor(TIntermTyped*& node) } // hook it up - node = parseContext.handleFunctionCall(arguments->getLoc(), constructorFunction, arguments); + node = _parseContext.handleFunctionCall(arguments->getLoc(), constructorFunction, arguments); return node != nullptr; } @@ -3191,7 +3191,7 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte TString* functionName = nullptr; if (baseObject == nullptr) { functionName = &name; - } else if (parseContext.isBuiltInMethod(loc, baseObject, name)) { + } else if (_parseContext.isBuiltInMethod(loc, baseObject, name)) { // Built-in methods are not in the symbol table as methods, but as global functions // taking an explicit 'this' as the first argument. functionName = NewPoolTString(BUILTIN_PREFIX); @@ -3203,7 +3203,7 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte } functionName = NewPoolTString(""); functionName->append(baseObject->getType().getTypeName()); - parseContext.addScopeMangler(*functionName); + _parseContext.addScopeMangler(*functionName); functionName->append(name); } @@ -3214,13 +3214,13 @@ bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TInte TIntermTyped* arguments = nullptr; if (baseObject != nullptr) { // Non-static member functions have an implicit first argument of the base object. - parseContext.handleFunctionArgument(function, arguments, baseObject); + _parseContext.handleFunctionArgument(function, arguments, baseObject); } if (! acceptArguments(function, arguments)) return false; // call - node = parseContext.handleFunctionCall(loc, function, arguments); + node = _parseContext.handleFunctionCall(loc, function, arguments); return node != nullptr; } @@ -3249,7 +3249,7 @@ bool HlslGrammar::acceptArguments(TFunction* function, TIntermTyped*& arguments) return false; // hook it up - parseContext.handleFunctionArgument(function, arguments, arg); + _parseContext.handleFunctionArgument(function, arguments, arg); // COMMA if (! acceptTokenClass(EHTokComma)) @@ -3348,7 +3348,7 @@ bool HlslGrammar::acceptCompoundStatement(TIntermNode*& retStatement) if (branch != nullptr && (branch->getFlowOp() == EOpCase || branch->getFlowOp() == EOpDefault)) { // hook up individual subsequences within a switch statement - parseContext.wrapupSwitchSubsequence(compoundStatement, statement); + _parseContext.wrapupSwitchSubsequence(compoundStatement, statement); compoundStatement = nullptr; } else { // hook it up to the growing compound statement @@ -3366,18 +3366,18 @@ bool HlslGrammar::acceptCompoundStatement(TIntermNode*& retStatement) bool HlslGrammar::acceptScopedStatement(TIntermNode*& statement) { - parseContext.pushScope(); + _parseContext.pushScope(); bool result = acceptStatement(statement); - parseContext.popScope(); + _parseContext.popScope(); return result; } bool HlslGrammar::acceptScopedCompoundStatement(TIntermNode*& statement) { - parseContext.pushScope(); + _parseContext.pushScope(); bool result = acceptCompoundStatement(statement); - parseContext.popScope(); + _parseContext.popScope(); return result; } @@ -3545,9 +3545,9 @@ void HlslGrammar::acceptAttributes(TAttributes& attributes) // Add any values we found into the attribute map. if (attributeToken.string != nullptr) { - TAttributeType attributeType = parseContext.attributeFromName(nameSpace, *attributeToken.string); + TAttributeType attributeType = _parseContext.attributeFromName(nameSpace, *attributeToken.string); if (attributeType == EatNone) - parseContext.warn(attributeToken.loc, "unrecognized attribute", attributeToken.string->c_str(), ""); + _parseContext.warn(attributeToken.loc, "unrecognized attribute", attributeToken.string->c_str(), ""); else { TAttributeArgs attributeArgs = { attributeType, expressions }; attributes.push_back(attributeArgs); @@ -3570,20 +3570,20 @@ bool HlslGrammar::acceptSelectionStatement(TIntermNode*& statement, const TAttri // so that something declared in the condition is scoped to the lifetimes // of the then-else statements - parseContext.pushScope(); + _parseContext.pushScope(); // LEFT_PAREN expression RIGHT_PAREN TIntermTyped* condition; if (! acceptParenExpression(condition)) return false; - condition = parseContext.convertConditionalExpression(loc, condition); + condition = _parseContext.convertConditionalExpression(loc, condition); if (condition == nullptr) return false; // create the child statements TIntermNodePair thenElse = { nullptr, nullptr }; - ++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors + ++_parseContext.controlFlowNestingLevel; // this only needs to work right if no errors // then statement if (! acceptScopedStatement(thenElse.node1)) { @@ -3602,10 +3602,10 @@ bool HlslGrammar::acceptSelectionStatement(TIntermNode*& statement, const TAttri // Put the pieces together statement = intermediate.addSelection(condition, thenElse, loc); - parseContext.handleSelectionAttributes(loc, statement->getAsSelectionNode(), attributes); + _parseContext.handleSelectionAttributes(loc, statement->getAsSelectionNode(), attributes); - parseContext.popScope(); - --parseContext.controlFlowNestingLevel; + _parseContext.popScope(); + --_parseContext.controlFlowNestingLevel; return true; } @@ -3622,26 +3622,26 @@ bool HlslGrammar::acceptSwitchStatement(TIntermNode*& statement, const TAttribut return false; // LEFT_PAREN expression RIGHT_PAREN - parseContext.pushScope(); + _parseContext.pushScope(); TIntermTyped* switchExpression; if (! acceptParenExpression(switchExpression)) { - parseContext.popScope(); + _parseContext.popScope(); return false; } // compound_statement - parseContext.pushSwitchSequence(new TIntermSequence); + _parseContext.pushSwitchSequence(new TIntermSequence); - ++parseContext.controlFlowNestingLevel; + ++_parseContext.controlFlowNestingLevel; bool statementOkay = acceptCompoundStatement(statement); - --parseContext.controlFlowNestingLevel; + --_parseContext.controlFlowNestingLevel; if (statementOkay) - statement = parseContext.addSwitch(loc, switchExpression, statement ? statement->getAsAggregate() : nullptr, + statement = _parseContext.addSwitch(loc, switchExpression, statement ? statement->getAsAggregate() : nullptr, attributes); - parseContext.popSwitchSequence(); - parseContext.popScope(); + _parseContext.popSwitchSequence(); + _parseContext.popScope(); return statementOkay; } @@ -3668,14 +3668,14 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri case EHTokWhile: // so that something declared in the condition is scoped to the lifetime // of the while sub-statement - parseContext.pushScope(); // this only needs to work right if no errors - parseContext.nestLooping(); - ++parseContext.controlFlowNestingLevel; + _parseContext.pushScope(); // this only needs to work right if no errors + _parseContext.nestLooping(); + ++_parseContext.controlFlowNestingLevel; // LEFT_PAREN condition RIGHT_PAREN if (! acceptParenExpression(condition)) return false; - condition = parseContext.convertConditionalExpression(loc, condition); + condition = _parseContext.convertConditionalExpression(loc, condition); if (condition == nullptr) return false; @@ -3685,17 +3685,17 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri return false; } - parseContext.unnestLooping(); - parseContext.popScope(); - --parseContext.controlFlowNestingLevel; + _parseContext.unnestLooping(); + _parseContext.popScope(); + --_parseContext.controlFlowNestingLevel; loopNode = intermediate.addLoop(statement, condition, nullptr, true, loc); statement = loopNode; break; case EHTokDo: - parseContext.nestLooping(); // this only needs to work right if no errors - ++parseContext.controlFlowNestingLevel; + _parseContext.nestLooping(); // this only needs to work right if no errors + ++_parseContext.controlFlowNestingLevel; // statement if (! acceptScopedStatement(statement)) { @@ -3712,15 +3712,15 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri // LEFT_PAREN condition RIGHT_PAREN if (! acceptParenExpression(condition)) return false; - condition = parseContext.convertConditionalExpression(loc, condition); + condition = _parseContext.convertConditionalExpression(loc, condition); if (condition == nullptr) return false; if (! acceptTokenClass(EHTokSemicolon)) expected(";"); - parseContext.unnestLooping(); - --parseContext.controlFlowNestingLevel; + _parseContext.unnestLooping(); + --_parseContext.controlFlowNestingLevel; loopNode = intermediate.addLoop(statement, condition, 0, false, loc); statement = loopNode; @@ -3734,22 +3734,22 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri // so that something declared in the condition is scoped to the lifetime // of the for sub-statement - parseContext.pushScope(); + _parseContext.pushScope(); // initializer TIntermNode* initNode = nullptr; if (! acceptSimpleStatement(initNode)) expected("for-loop initializer statement"); - parseContext.nestLooping(); // this only needs to work right if no errors - ++parseContext.controlFlowNestingLevel; + _parseContext.nestLooping(); // this only needs to work right if no errors + ++_parseContext.controlFlowNestingLevel; // condition SEMI_COLON acceptExpression(condition); if (! acceptTokenClass(EHTokSemicolon)) expected(";"); if (condition != nullptr) { - condition = parseContext.convertConditionalExpression(loc, condition); + condition = _parseContext.convertConditionalExpression(loc, condition); if (condition == nullptr) return false; } @@ -3768,9 +3768,9 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri statement = intermediate.addForLoop(statement, initNode, condition, iterator, true, loc, loopNode); - parseContext.popScope(); - parseContext.unnestLooping(); - --parseContext.controlFlowNestingLevel; + _parseContext.popScope(); + _parseContext.unnestLooping(); + --_parseContext.controlFlowNestingLevel; break; } @@ -3779,7 +3779,7 @@ bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttri return false; } - parseContext.handleLoopAttributes(loc, loopNode, attributes); + _parseContext.handleLoopAttributes(loc, loopNode, attributes); return true; } @@ -3808,14 +3808,14 @@ bool HlslGrammar::acceptJumpStatement(TIntermNode*& statement) switch (jump) { case EHTokContinue: statement = intermediate.addBranch(EOpContinue, token.loc); - if (parseContext.loopNestingLevel == 0) { + if (_parseContext.loopNestingLevel == 0) { expected("loop"); return false; } break; case EHTokBreak: statement = intermediate.addBranch(EOpBreak, token.loc); - if (parseContext.loopNestingLevel == 0 && parseContext.switchSequenceStack.size() == 0) { + if (_parseContext.loopNestingLevel == 0 && _parseContext.switchSequenceStack.size() == 0) { expected("loop or switch"); return false; } @@ -3830,7 +3830,7 @@ bool HlslGrammar::acceptJumpStatement(TIntermNode*& statement) TIntermTyped* node; if (acceptExpression(node)) { // hook it up - statement = parseContext.handleReturnValue(token.loc, node); + statement = _parseContext.handleReturnValue(token.loc, node); } else statement = intermediate.addBranch(EOpReturn, token.loc); break; @@ -3868,7 +3868,7 @@ bool HlslGrammar::acceptCaseLabel(TIntermNode*& statement) return false; } - statement = parseContext.intermediate.addBranch(EOpCase, expression, loc); + statement = _parseContext.intermediate.addBranch(EOpCase, expression, loc); return true; } @@ -3887,7 +3887,7 @@ bool HlslGrammar::acceptDefaultLabel(TIntermNode*& statement) return false; } - statement = parseContext.intermediate.addBranch(EOpDefault, loc); + statement = _parseContext.intermediate.addBranch(EOpDefault, loc); return true; } @@ -3922,7 +3922,7 @@ void HlslGrammar::acceptArraySpecifier(TArraySizes*& arraySizes) if (hasArraySize) { TArraySize arraySize; - parseContext.arraySizeCheck(loc, sizeExpr, arraySize); + _parseContext.arraySizeCheck(loc, sizeExpr, arraySize); arraySizes->addInnerSize(arraySize); } else { arraySizes->addInnerSize(0); // sized by initializers. @@ -3974,7 +3974,7 @@ bool HlslGrammar::acceptPostDecls(TQualifier& qualifier) expected(")"); break; } - parseContext.handlePackOffset(locationToken.loc, qualifier, *locationToken.string, componentToken.string); + _parseContext.handlePackOffset(locationToken.loc, qualifier, *locationToken.string, componentToken.string); } else if (! acceptIdentifier(idToken)) { expected("layout, semantic, packoffset, or register"); return false; @@ -4028,12 +4028,12 @@ bool HlslGrammar::acceptPostDecls(TQualifier& qualifier) expected(")"); break; } - parseContext.handleRegister(registerDesc.loc, qualifier, profile.string, *registerDesc.string, subComponent, spaceDesc.string); + _parseContext.handleRegister(registerDesc.loc, qualifier, profile.string, *registerDesc.string, subComponent, spaceDesc.string); } else { // semantic, in idToken.string TString semanticUpperCase = *idToken.string; std::transform(semanticUpperCase.begin(), semanticUpperCase.end(), semanticUpperCase.begin(), ::toupper); - parseContext.handleSemantic(idToken.loc, qualifier, mapSemantic(semanticUpperCase.c_str()), semanticUpperCase); + _parseContext.handleSemantic(idToken.loc, qualifier, mapSemantic(semanticUpperCase.c_str()), semanticUpperCase); } } else if (peekTokenClass(EHTokLeftAngle)) { found = true; diff --git a/deps/glslang/glslang/hlsl/hlslGrammar.h b/deps/glslang/glslang/hlsl/hlslGrammar.h index 046f7957e5..f15ccca0cf 100755 --- a/deps/glslang/glslang/hlsl/hlslGrammar.h +++ b/deps/glslang/glslang/hlsl/hlslGrammar.h @@ -50,8 +50,8 @@ namespace glslang { class HlslGrammar : public HlslTokenStream { public: - HlslGrammar(HlslScanContext& scanner, HlslParseContext& parseContext) - : HlslTokenStream(scanner), parseContext(parseContext), intermediate(parseContext.intermediate), + HlslGrammar(HlslScanContext& scanner, HlslParseContext& _parseContext) + : HlslTokenStream(scanner), _parseContext(_parseContext), intermediate(_parseContext.intermediate), typeIdentifiers(false) { } virtual ~HlslGrammar() { } @@ -130,7 +130,7 @@ namespace glslang { bool captureBlockTokens(TVector& tokens); const char* getTypeString(EHlslTokenClass tokenClass) const; - HlslParseContext& parseContext; // state of parsing and helper functions for building the intermediate + HlslParseContext& _parseContext; // state of parsing and helper functions for building the intermediate TIntermediate& intermediate; // the final product, the intermediate representation, includes the AST bool typeIdentifiers; // shader uses some types as identifiers }; diff --git a/deps/glslang/glslang/hlsl/hlslScanContext.cpp b/deps/glslang/glslang/hlsl/hlslScanContext.cpp index 28a66bb47d..4414eb7aa8 100755 --- a/deps/glslang/glslang/hlsl/hlslScanContext.cpp +++ b/deps/glslang/glslang/hlsl/hlslScanContext.cpp @@ -51,37 +51,15 @@ // preprocessor includes #include "../glslang/MachineIndependent/preprocessor/PpContext.h" #include "../glslang/MachineIndependent/preprocessor/PpTokens.h" +#include "../glslang/MachineIndependent/preprocessor/Compare.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* KeywordMap = nullptr; -std::unordered_set* ReservedSet = nullptr; -std::unordered_map* SemanticMap = nullptr; +std::unordered_map* hlslKeywordMap = nullptr; +std::unordered_set* hlslReservedSet = nullptr; +std::unordered_map* hlslSemanticMap = nullptr; }; @@ -89,323 +67,323 @@ namespace glslang { void HlslScanContext::fillInKeywordMap() { - if (KeywordMap != nullptr) { + if (hlslKeywordMap != 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; + hlslKeywordMap = new std::unordered_map; - (*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; + (*hlslKeywordMap)["static"] = EHTokStatic; + (*hlslKeywordMap)["const"] = EHTokConst; + (*hlslKeywordMap)["unorm"] = EHTokUnorm; + (*hlslKeywordMap)["snorm"] = EHTokSNorm; + (*hlslKeywordMap)["extern"] = EHTokExtern; + (*hlslKeywordMap)["uniform"] = EHTokUniform; + (*hlslKeywordMap)["volatile"] = EHTokVolatile; + (*hlslKeywordMap)["precise"] = EHTokPrecise; + (*hlslKeywordMap)["shared"] = EHTokShared; + (*hlslKeywordMap)["groupshared"] = EHTokGroupShared; + (*hlslKeywordMap)["linear"] = EHTokLinear; + (*hlslKeywordMap)["centroid"] = EHTokCentroid; + (*hlslKeywordMap)["nointerpolation"] = EHTokNointerpolation; + (*hlslKeywordMap)["noperspective"] = EHTokNoperspective; + (*hlslKeywordMap)["sample"] = EHTokSample; + (*hlslKeywordMap)["row_major"] = EHTokRowMajor; + (*hlslKeywordMap)["column_major"] = EHTokColumnMajor; + (*hlslKeywordMap)["packoffset"] = EHTokPackOffset; + (*hlslKeywordMap)["in"] = EHTokIn; + (*hlslKeywordMap)["out"] = EHTokOut; + (*hlslKeywordMap)["inout"] = EHTokInOut; + (*hlslKeywordMap)["layout"] = EHTokLayout; + (*hlslKeywordMap)["globallycoherent"] = EHTokGloballyCoherent; + (*hlslKeywordMap)["inline"] = EHTokInline; - (*KeywordMap)["point"] = EHTokPoint; - (*KeywordMap)["line"] = EHTokLine; - (*KeywordMap)["triangle"] = EHTokTriangle; - (*KeywordMap)["lineadj"] = EHTokLineAdj; - (*KeywordMap)["triangleadj"] = EHTokTriangleAdj; + (*hlslKeywordMap)["point"] = EHTokPoint; + (*hlslKeywordMap)["line"] = EHTokLine; + (*hlslKeywordMap)["triangle"] = EHTokTriangle; + (*hlslKeywordMap)["lineadj"] = EHTokLineAdj; + (*hlslKeywordMap)["triangleadj"] = EHTokTriangleAdj; - (*KeywordMap)["PointStream"] = EHTokPointStream; - (*KeywordMap)["LineStream"] = EHTokLineStream; - (*KeywordMap)["TriangleStream"] = EHTokTriangleStream; + (*hlslKeywordMap)["PointStream"] = EHTokPointStream; + (*hlslKeywordMap)["LineStream"] = EHTokLineStream; + (*hlslKeywordMap)["TriangleStream"] = EHTokTriangleStream; - (*KeywordMap)["InputPatch"] = EHTokInputPatch; - (*KeywordMap)["OutputPatch"] = EHTokOutputPatch; + (*hlslKeywordMap)["InputPatch"] = EHTokInputPatch; + (*hlslKeywordMap)["OutputPatch"] = EHTokOutputPatch; - (*KeywordMap)["Buffer"] = EHTokBuffer; - (*KeywordMap)["vector"] = EHTokVector; - (*KeywordMap)["matrix"] = EHTokMatrix; + (*hlslKeywordMap)["Buffer"] = EHTokBuffer; + (*hlslKeywordMap)["vector"] = EHTokVector; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["void"] = EHTokVoid; + (*hlslKeywordMap)["string"] = EHTokString; + (*hlslKeywordMap)["bool"] = EHTokBool; + (*hlslKeywordMap)["int"] = EHTokInt; + (*hlslKeywordMap)["uint"] = EHTokUint; + (*hlslKeywordMap)["uint64_t"] = EHTokUint64; + (*hlslKeywordMap)["dword"] = EHTokDword; + (*hlslKeywordMap)["half"] = EHTokHalf; + (*hlslKeywordMap)["float"] = EHTokFloat; + (*hlslKeywordMap)["double"] = EHTokDouble; + (*hlslKeywordMap)["min16float"] = EHTokMin16float; + (*hlslKeywordMap)["min10float"] = EHTokMin10float; + (*hlslKeywordMap)["min16int"] = EHTokMin16int; + (*hlslKeywordMap)["min12int"] = EHTokMin12int; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["bool1"] = EHTokBool1; + (*hlslKeywordMap)["bool2"] = EHTokBool2; + (*hlslKeywordMap)["bool3"] = EHTokBool3; + (*hlslKeywordMap)["bool4"] = EHTokBool4; + (*hlslKeywordMap)["float1"] = EHTokFloat1; + (*hlslKeywordMap)["float2"] = EHTokFloat2; + (*hlslKeywordMap)["float3"] = EHTokFloat3; + (*hlslKeywordMap)["float4"] = EHTokFloat4; + (*hlslKeywordMap)["int1"] = EHTokInt1; + (*hlslKeywordMap)["int2"] = EHTokInt2; + (*hlslKeywordMap)["int3"] = EHTokInt3; + (*hlslKeywordMap)["int4"] = EHTokInt4; + (*hlslKeywordMap)["double1"] = EHTokDouble1; + (*hlslKeywordMap)["double2"] = EHTokDouble2; + (*hlslKeywordMap)["double3"] = EHTokDouble3; + (*hlslKeywordMap)["double4"] = EHTokDouble4; + (*hlslKeywordMap)["uint1"] = EHTokUint1; + (*hlslKeywordMap)["uint2"] = EHTokUint2; + (*hlslKeywordMap)["uint3"] = EHTokUint3; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["half1"] = EHTokHalf1; + (*hlslKeywordMap)["half2"] = EHTokHalf2; + (*hlslKeywordMap)["half3"] = EHTokHalf3; + (*hlslKeywordMap)["half4"] = EHTokHalf4; + (*hlslKeywordMap)["min16float1"] = EHTokMin16float1; + (*hlslKeywordMap)["min16float2"] = EHTokMin16float2; + (*hlslKeywordMap)["min16float3"] = EHTokMin16float3; + (*hlslKeywordMap)["min16float4"] = EHTokMin16float4; + (*hlslKeywordMap)["min10float1"] = EHTokMin10float1; + (*hlslKeywordMap)["min10float2"] = EHTokMin10float2; + (*hlslKeywordMap)["min10float3"] = EHTokMin10float3; + (*hlslKeywordMap)["min10float4"] = EHTokMin10float4; + (*hlslKeywordMap)["min16int1"] = EHTokMin16int1; + (*hlslKeywordMap)["min16int2"] = EHTokMin16int2; + (*hlslKeywordMap)["min16int3"] = EHTokMin16int3; + (*hlslKeywordMap)["min16int4"] = EHTokMin16int4; + (*hlslKeywordMap)["min12int1"] = EHTokMin12int1; + (*hlslKeywordMap)["min12int2"] = EHTokMin12int2; + (*hlslKeywordMap)["min12int3"] = EHTokMin12int3; + (*hlslKeywordMap)["min12int4"] = EHTokMin12int4; + (*hlslKeywordMap)["min16uint1"] = EHTokMin16uint1; + (*hlslKeywordMap)["min16uint2"] = EHTokMin16uint2; + (*hlslKeywordMap)["min16uint3"] = EHTokMin16uint3; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["bool1x1"] = EHTokBool1x1; + (*hlslKeywordMap)["bool1x2"] = EHTokBool1x2; + (*hlslKeywordMap)["bool1x3"] = EHTokBool1x3; + (*hlslKeywordMap)["bool1x4"] = EHTokBool1x4; + (*hlslKeywordMap)["bool2x1"] = EHTokBool2x1; + (*hlslKeywordMap)["bool2x2"] = EHTokBool2x2; + (*hlslKeywordMap)["bool2x3"] = EHTokBool2x3; + (*hlslKeywordMap)["bool2x4"] = EHTokBool2x4; + (*hlslKeywordMap)["bool3x1"] = EHTokBool3x1; + (*hlslKeywordMap)["bool3x2"] = EHTokBool3x2; + (*hlslKeywordMap)["bool3x3"] = EHTokBool3x3; + (*hlslKeywordMap)["bool3x4"] = EHTokBool3x4; + (*hlslKeywordMap)["bool4x1"] = EHTokBool4x1; + (*hlslKeywordMap)["bool4x2"] = EHTokBool4x2; + (*hlslKeywordMap)["bool4x3"] = EHTokBool4x3; + (*hlslKeywordMap)["bool4x4"] = EHTokBool4x4; + (*hlslKeywordMap)["int1x1"] = EHTokInt1x1; + (*hlslKeywordMap)["int1x2"] = EHTokInt1x2; + (*hlslKeywordMap)["int1x3"] = EHTokInt1x3; + (*hlslKeywordMap)["int1x4"] = EHTokInt1x4; + (*hlslKeywordMap)["int2x1"] = EHTokInt2x1; + (*hlslKeywordMap)["int2x2"] = EHTokInt2x2; + (*hlslKeywordMap)["int2x3"] = EHTokInt2x3; + (*hlslKeywordMap)["int2x4"] = EHTokInt2x4; + (*hlslKeywordMap)["int3x1"] = EHTokInt3x1; + (*hlslKeywordMap)["int3x2"] = EHTokInt3x2; + (*hlslKeywordMap)["int3x3"] = EHTokInt3x3; + (*hlslKeywordMap)["int3x4"] = EHTokInt3x4; + (*hlslKeywordMap)["int4x1"] = EHTokInt4x1; + (*hlslKeywordMap)["int4x2"] = EHTokInt4x2; + (*hlslKeywordMap)["int4x3"] = EHTokInt4x3; + (*hlslKeywordMap)["int4x4"] = EHTokInt4x4; + (*hlslKeywordMap)["uint1x1"] = EHTokUint1x1; + (*hlslKeywordMap)["uint1x2"] = EHTokUint1x2; + (*hlslKeywordMap)["uint1x3"] = EHTokUint1x3; + (*hlslKeywordMap)["uint1x4"] = EHTokUint1x4; + (*hlslKeywordMap)["uint2x1"] = EHTokUint2x1; + (*hlslKeywordMap)["uint2x2"] = EHTokUint2x2; + (*hlslKeywordMap)["uint2x3"] = EHTokUint2x3; + (*hlslKeywordMap)["uint2x4"] = EHTokUint2x4; + (*hlslKeywordMap)["uint3x1"] = EHTokUint3x1; + (*hlslKeywordMap)["uint3x2"] = EHTokUint3x2; + (*hlslKeywordMap)["uint3x3"] = EHTokUint3x3; + (*hlslKeywordMap)["uint3x4"] = EHTokUint3x4; + (*hlslKeywordMap)["uint4x1"] = EHTokUint4x1; + (*hlslKeywordMap)["uint4x2"] = EHTokUint4x2; + (*hlslKeywordMap)["uint4x3"] = EHTokUint4x3; + (*hlslKeywordMap)["uint4x4"] = EHTokUint4x4; + (*hlslKeywordMap)["bool1x1"] = EHTokBool1x1; + (*hlslKeywordMap)["bool1x2"] = EHTokBool1x2; + (*hlslKeywordMap)["bool1x3"] = EHTokBool1x3; + (*hlslKeywordMap)["bool1x4"] = EHTokBool1x4; + (*hlslKeywordMap)["bool2x1"] = EHTokBool2x1; + (*hlslKeywordMap)["bool2x2"] = EHTokBool2x2; + (*hlslKeywordMap)["bool2x3"] = EHTokBool2x3; + (*hlslKeywordMap)["bool2x4"] = EHTokBool2x4; + (*hlslKeywordMap)["bool3x1"] = EHTokBool3x1; + (*hlslKeywordMap)["bool3x2"] = EHTokBool3x2; + (*hlslKeywordMap)["bool3x3"] = EHTokBool3x3; + (*hlslKeywordMap)["bool3x4"] = EHTokBool3x4; + (*hlslKeywordMap)["bool4x1"] = EHTokBool4x1; + (*hlslKeywordMap)["bool4x2"] = EHTokBool4x2; + (*hlslKeywordMap)["bool4x3"] = EHTokBool4x3; + (*hlslKeywordMap)["bool4x4"] = EHTokBool4x4; + (*hlslKeywordMap)["float1x1"] = EHTokFloat1x1; + (*hlslKeywordMap)["float1x2"] = EHTokFloat1x2; + (*hlslKeywordMap)["float1x3"] = EHTokFloat1x3; + (*hlslKeywordMap)["float1x4"] = EHTokFloat1x4; + (*hlslKeywordMap)["float2x1"] = EHTokFloat2x1; + (*hlslKeywordMap)["float2x2"] = EHTokFloat2x2; + (*hlslKeywordMap)["float2x3"] = EHTokFloat2x3; + (*hlslKeywordMap)["float2x4"] = EHTokFloat2x4; + (*hlslKeywordMap)["float3x1"] = EHTokFloat3x1; + (*hlslKeywordMap)["float3x2"] = EHTokFloat3x2; + (*hlslKeywordMap)["float3x3"] = EHTokFloat3x3; + (*hlslKeywordMap)["float3x4"] = EHTokFloat3x4; + (*hlslKeywordMap)["float4x1"] = EHTokFloat4x1; + (*hlslKeywordMap)["float4x2"] = EHTokFloat4x2; + (*hlslKeywordMap)["float4x3"] = EHTokFloat4x3; + (*hlslKeywordMap)["float4x4"] = EHTokFloat4x4; + (*hlslKeywordMap)["half1x1"] = EHTokHalf1x1; + (*hlslKeywordMap)["half1x2"] = EHTokHalf1x2; + (*hlslKeywordMap)["half1x3"] = EHTokHalf1x3; + (*hlslKeywordMap)["half1x4"] = EHTokHalf1x4; + (*hlslKeywordMap)["half2x1"] = EHTokHalf2x1; + (*hlslKeywordMap)["half2x2"] = EHTokHalf2x2; + (*hlslKeywordMap)["half2x3"] = EHTokHalf2x3; + (*hlslKeywordMap)["half2x4"] = EHTokHalf2x4; + (*hlslKeywordMap)["half3x1"] = EHTokHalf3x1; + (*hlslKeywordMap)["half3x2"] = EHTokHalf3x2; + (*hlslKeywordMap)["half3x3"] = EHTokHalf3x3; + (*hlslKeywordMap)["half3x4"] = EHTokHalf3x4; + (*hlslKeywordMap)["half4x1"] = EHTokHalf4x1; + (*hlslKeywordMap)["half4x2"] = EHTokHalf4x2; + (*hlslKeywordMap)["half4x3"] = EHTokHalf4x3; + (*hlslKeywordMap)["half4x4"] = EHTokHalf4x4; + (*hlslKeywordMap)["double1x1"] = EHTokDouble1x1; + (*hlslKeywordMap)["double1x2"] = EHTokDouble1x2; + (*hlslKeywordMap)["double1x3"] = EHTokDouble1x3; + (*hlslKeywordMap)["double1x4"] = EHTokDouble1x4; + (*hlslKeywordMap)["double2x1"] = EHTokDouble2x1; + (*hlslKeywordMap)["double2x2"] = EHTokDouble2x2; + (*hlslKeywordMap)["double2x3"] = EHTokDouble2x3; + (*hlslKeywordMap)["double2x4"] = EHTokDouble2x4; + (*hlslKeywordMap)["double3x1"] = EHTokDouble3x1; + (*hlslKeywordMap)["double3x2"] = EHTokDouble3x2; + (*hlslKeywordMap)["double3x3"] = EHTokDouble3x3; + (*hlslKeywordMap)["double3x4"] = EHTokDouble3x4; + (*hlslKeywordMap)["double4x1"] = EHTokDouble4x1; + (*hlslKeywordMap)["double4x2"] = EHTokDouble4x2; + (*hlslKeywordMap)["double4x3"] = EHTokDouble4x3; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["sampler"] = EHTokSampler; + (*hlslKeywordMap)["sampler1D"] = EHTokSampler1d; + (*hlslKeywordMap)["sampler2D"] = EHTokSampler2d; + (*hlslKeywordMap)["sampler3D"] = EHTokSampler3d; + (*hlslKeywordMap)["samplerCube"] = EHTokSamplerCube; + (*hlslKeywordMap)["sampler_state"] = EHTokSamplerState; + (*hlslKeywordMap)["SamplerState"] = EHTokSamplerState; + (*hlslKeywordMap)["SamplerComparisonState"] = EHTokSamplerComparisonState; + (*hlslKeywordMap)["texture"] = EHTokTexture; + (*hlslKeywordMap)["Texture1D"] = EHTokTexture1d; + (*hlslKeywordMap)["Texture1DArray"] = EHTokTexture1darray; + (*hlslKeywordMap)["Texture2D"] = EHTokTexture2d; + (*hlslKeywordMap)["Texture2DArray"] = EHTokTexture2darray; + (*hlslKeywordMap)["Texture3D"] = EHTokTexture3d; + (*hlslKeywordMap)["TextureCube"] = EHTokTextureCube; + (*hlslKeywordMap)["TextureCubeArray"] = EHTokTextureCubearray; + (*hlslKeywordMap)["Texture2DMS"] = EHTokTexture2DMS; + (*hlslKeywordMap)["Texture2DMSArray"] = EHTokTexture2DMSarray; + (*hlslKeywordMap)["RWTexture1D"] = EHTokRWTexture1d; + (*hlslKeywordMap)["RWTexture1DArray"] = EHTokRWTexture1darray; + (*hlslKeywordMap)["RWTexture2D"] = EHTokRWTexture2d; + (*hlslKeywordMap)["RWTexture2DArray"] = EHTokRWTexture2darray; + (*hlslKeywordMap)["RWTexture3D"] = EHTokRWTexture3d; + (*hlslKeywordMap)["RWBuffer"] = EHTokRWBuffer; + (*hlslKeywordMap)["SubpassInput"] = EHTokSubpassInput; + (*hlslKeywordMap)["SubpassInputMS"] = EHTokSubpassInputMS; - (*KeywordMap)["AppendStructuredBuffer"] = EHTokAppendStructuredBuffer; - (*KeywordMap)["ByteAddressBuffer"] = EHTokByteAddressBuffer; - (*KeywordMap)["ConsumeStructuredBuffer"] = EHTokConsumeStructuredBuffer; - (*KeywordMap)["RWByteAddressBuffer"] = EHTokRWByteAddressBuffer; - (*KeywordMap)["RWStructuredBuffer"] = EHTokRWStructuredBuffer; - (*KeywordMap)["StructuredBuffer"] = EHTokStructuredBuffer; - (*KeywordMap)["TextureBuffer"] = EHTokTextureBuffer; + (*hlslKeywordMap)["AppendStructuredBuffer"] = EHTokAppendStructuredBuffer; + (*hlslKeywordMap)["ByteAddressBuffer"] = EHTokByteAddressBuffer; + (*hlslKeywordMap)["ConsumeStructuredBuffer"] = EHTokConsumeStructuredBuffer; + (*hlslKeywordMap)["RWByteAddressBuffer"] = EHTokRWByteAddressBuffer; + (*hlslKeywordMap)["RWStructuredBuffer"] = EHTokRWStructuredBuffer; + (*hlslKeywordMap)["StructuredBuffer"] = EHTokStructuredBuffer; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["class"] = EHTokClass; + (*hlslKeywordMap)["struct"] = EHTokStruct; + (*hlslKeywordMap)["cbuffer"] = EHTokCBuffer; + (*hlslKeywordMap)["ConstantBuffer"] = EHTokConstantBuffer; + (*hlslKeywordMap)["tbuffer"] = EHTokTBuffer; + (*hlslKeywordMap)["typedef"] = EHTokTypedef; + (*hlslKeywordMap)["this"] = EHTokThis; + (*hlslKeywordMap)["namespace"] = EHTokNamespace; - (*KeywordMap)["true"] = EHTokBoolConstant; - (*KeywordMap)["false"] = EHTokBoolConstant; + (*hlslKeywordMap)["true"] = EHTokBoolConstant; + (*hlslKeywordMap)["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; + (*hlslKeywordMap)["for"] = EHTokFor; + (*hlslKeywordMap)["do"] = EHTokDo; + (*hlslKeywordMap)["while"] = EHTokWhile; + (*hlslKeywordMap)["break"] = EHTokBreak; + (*hlslKeywordMap)["continue"] = EHTokContinue; + (*hlslKeywordMap)["if"] = EHTokIf; + (*hlslKeywordMap)["else"] = EHTokElse; + (*hlslKeywordMap)["discard"] = EHTokDiscard; + (*hlslKeywordMap)["return"] = EHTokReturn; + (*hlslKeywordMap)["switch"] = EHTokSwitch; + (*hlslKeywordMap)["case"] = EHTokCase; + (*hlslKeywordMap)["default"] = EHTokDefault; // TODO: get correct set here - ReservedSet = new std::unordered_set; + hlslReservedSet = new std::unordered_set; - 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"); + hlslReservedSet->insert("auto"); + hlslReservedSet->insert("catch"); + hlslReservedSet->insert("char"); + hlslReservedSet->insert("const_cast"); + hlslReservedSet->insert("enum"); + hlslReservedSet->insert("explicit"); + hlslReservedSet->insert("friend"); + hlslReservedSet->insert("goto"); + hlslReservedSet->insert("long"); + hlslReservedSet->insert("mutable"); + hlslReservedSet->insert("new"); + hlslReservedSet->insert("operator"); + hlslReservedSet->insert("private"); + hlslReservedSet->insert("protected"); + hlslReservedSet->insert("public"); + hlslReservedSet->insert("reinterpret_cast"); + hlslReservedSet->insert("short"); + hlslReservedSet->insert("signed"); + hlslReservedSet->insert("sizeof"); + hlslReservedSet->insert("static_cast"); + hlslReservedSet->insert("template"); + hlslReservedSet->insert("throw"); + hlslReservedSet->insert("try"); + hlslReservedSet->insert("typename"); + hlslReservedSet->insert("union"); + hlslReservedSet->insert("unsigned"); + hlslReservedSet->insert("using"); + hlslReservedSet->insert("virtual"); - SemanticMap = new std::unordered_map; + hlslSemanticMap = new std::unordered_map; // 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 @@ -416,45 +394,45 @@ void HlslScanContext::fillInKeywordMap() // to the next bool bParseDX9 = false; if (bParseDX9) { - (*SemanticMap)["PSIZE"] = EbvPointSize; - (*SemanticMap)["FOG"] = EbvFogFragCoord; - (*SemanticMap)["DEPTH"] = EbvFragDepth; - (*SemanticMap)["VFACE"] = EbvFace; - (*SemanticMap)["VPOS"] = EbvFragCoord; + (*hlslSemanticMap)["PSIZE"] = EbvPointSize; + (*hlslSemanticMap)["FOG"] = EbvFogFragCoord; + (*hlslSemanticMap)["DEPTH"] = EbvFragDepth; + (*hlslSemanticMap)["VFACE"] = EbvFace; + (*hlslSemanticMap)["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; + (*hlslSemanticMap)["SV_POSITION"] = EbvPosition; + (*hlslSemanticMap)["SV_VERTEXID"] = EbvVertexIndex; + (*hlslSemanticMap)["SV_VIEWPORTARRAYINDEX"] = EbvViewportIndex; + (*hlslSemanticMap)["SV_TESSFACTOR"] = EbvTessLevelOuter; + (*hlslSemanticMap)["SV_SAMPLEINDEX"] = EbvSampleId; + (*hlslSemanticMap)["SV_RENDERTARGETARRAYINDEX"] = EbvLayer; + (*hlslSemanticMap)["SV_PRIMITIVEID"] = EbvPrimitiveId; + (*hlslSemanticMap)["SV_OUTPUTCONTROLPOINTID"] = EbvInvocationId; + (*hlslSemanticMap)["SV_ISFRONTFACE"] = EbvFace; + (*hlslSemanticMap)["SV_INSTANCEID"] = EbvInstanceIndex; + (*hlslSemanticMap)["SV_INSIDETESSFACTOR"] = EbvTessLevelInner; + (*hlslSemanticMap)["SV_GSINSTANCEID"] = EbvInvocationId; + (*hlslSemanticMap)["SV_DISPATCHTHREADID"] = EbvGlobalInvocationId; + (*hlslSemanticMap)["SV_GROUPTHREADID"] = EbvLocalInvocationId; + (*hlslSemanticMap)["SV_GROUPINDEX"] = EbvLocalInvocationIndex; + (*hlslSemanticMap)["SV_GROUPID"] = EbvWorkGroupId; + (*hlslSemanticMap)["SV_DOMAINLOCATION"] = EbvTessCoord; + (*hlslSemanticMap)["SV_DEPTH"] = EbvFragDepth; + (*hlslSemanticMap)["SV_COVERAGE"] = EbvSampleMask; + (*hlslSemanticMap)["SV_DEPTHGREATEREQUAL"] = EbvFragDepthGreater; + (*hlslSemanticMap)["SV_DEPTHLESSEQUAL"] = EbvFragDepthLesser; + (*hlslSemanticMap)["SV_STENCILREF"] = EbvFragStencilRef; } void HlslScanContext::deleteKeywordMap() { - delete KeywordMap; - KeywordMap = nullptr; - delete ReservedSet; - ReservedSet = nullptr; - delete SemanticMap; - SemanticMap = nullptr; + delete hlslKeywordMap; + hlslKeywordMap = nullptr; + delete hlslReservedSet; + hlslReservedSet = nullptr; + delete hlslSemanticMap; + hlslSemanticMap = nullptr; } // Wrapper for tokenizeClass() to get everything inside the token. @@ -466,8 +444,8 @@ void HlslScanContext::tokenize(HlslToken& token) glslang::TBuiltInVariable HlslScanContext::mapSemantic(const char* upperCase) { - auto it = SemanticMap->find(upperCase); - if (it != SemanticMap->end()) + auto it = hlslSemanticMap->find(upperCase); + if (it != hlslSemanticMap->end()) return it->second; else return glslang::EbvNone; @@ -516,7 +494,7 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) case '{': return EHTokLeftBrace; case '}': return EHTokRightBrace; case '\\': - parseContext.error(loc, "illegal use of escape character", "\\", ""); + _parseContext.error(loc, "illegal use of escape character", "\\", ""); break; case PPAtomAddAssign: return EHTokAddAssign; @@ -571,11 +549,11 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) char buf[2]; buf[0] = (char)token; buf[1] = 0; - parseContext.error(loc, "unexpected token", buf, ""); + _parseContext.error(loc, "unexpected token", buf, ""); } else if (tokenText[0] != 0) - parseContext.error(loc, "unexpected token", tokenText, ""); + _parseContext.error(loc, "unexpected token", tokenText, ""); else - parseContext.error(loc, "unexpected token", "", ""); + _parseContext.error(loc, "unexpected token", "", ""); break; } } while (true); @@ -583,11 +561,11 @@ EHlslTokenClass HlslScanContext::tokenizeClass(HlslToken& token) EHlslTokenClass HlslScanContext::tokenizeIdentifier() { - if (ReservedSet->find(tokenText) != ReservedSet->end()) + if (hlslReservedSet->find(tokenText) != hlslReservedSet->end()) return reservedWord(); - auto it = KeywordMap->find(tokenText); - if (it == KeywordMap->end()) { + auto it = hlslKeywordMap->find(tokenText); + if (it == hlslKeywordMap->end()) { // Should have an identifier of some sort return identifierOrType(); } @@ -877,7 +855,7 @@ EHlslTokenClass HlslScanContext::tokenizeIdentifier() return keyword; default: - parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); + _parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc); return EHTokNone; } } @@ -894,8 +872,8 @@ EHlslTokenClass HlslScanContext::identifierOrType() // extension support before the extension is enabled. EHlslTokenClass HlslScanContext::reservedWord() { - if (! parseContext.symbolTable.atBuiltInLevel()) - parseContext.error(loc, "Reserved word.", tokenText, "", ""); + if (! _parseContext.symbolTable.atBuiltInLevel()) + _parseContext.error(loc, "Reserved word.", tokenText, "", ""); return EHTokNone; } diff --git a/deps/glslang/glslang/hlsl/hlslScanContext.h b/deps/glslang/glslang/hlsl/hlslScanContext.h index 9d30a12e1e..f7912c8d9b 100755 --- a/deps/glslang/glslang/hlsl/hlslScanContext.h +++ b/deps/glslang/glslang/hlsl/hlslScanContext.h @@ -73,8 +73,8 @@ struct HlslToken { // class HlslScanContext { public: - HlslScanContext(TParseContextBase& parseContext, TPpContext& ppContext) - : parseContext(parseContext), ppContext(ppContext) { } + HlslScanContext(TParseContextBase& _parseContext, TPpContext& ppContext) + : _parseContext(_parseContext), ppContext(ppContext) { } virtual ~HlslScanContext() { } static void fillInKeywordMap(); @@ -94,7 +94,7 @@ protected: EHlslTokenClass identifierOrReserved(bool reserved); EHlslTokenClass nonreservedKeyword(int version); - TParseContextBase& parseContext; + TParseContextBase& _parseContext; TPpContext& ppContext; TSourceLoc loc; TPpToken* ppToken; diff --git a/griffin/griffin_glslang.cpp b/griffin/griffin_glslang.cpp index 44c33866d6..606c2bbf7d 100644 --- a/griffin/griffin_glslang.cpp +++ b/griffin/griffin_glslang.cpp @@ -21,6 +21,7 @@ #include "../deps/glslang/glslang/OGLCompilersDLL/InitializeDll.cpp" +#include "../deps/glslang/glslang/glslang/MachineIndependent/attribute.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/Constant.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/glslang_tab.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/InfoSink.cpp" @@ -46,9 +47,7 @@ #include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp" -#include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpMemory.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp" -#include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpSymbols.cpp" #include "../deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp" #include "../deps/glslang/glslang/hlsl/hlslAttributes.cpp" diff --git a/pkg/msvc/RetroArch-msvc2017.sln b/pkg/msvc/RetroArch-msvc2017.sln index e7871290e2..c09332a7d5 100644 --- a/pkg/msvc/RetroArch-msvc2017.sln +++ b/pkg/msvc/RetroArch-msvc2017.sln @@ -61,7 +61,4 @@ Global GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {C7897994-5FD9-4B08-93CB-5EF58C48CFC6} - EndGlobalSection EndGlobal diff --git a/pkg/msvc/msvc-2013/RetroArch-msvc2013.vcxproj b/pkg/msvc/msvc-2013/RetroArch-msvc2013.vcxproj index 29d64e782f..30120062ea 100644 --- a/pkg/msvc/msvc-2013/RetroArch-msvc2013.vcxproj +++ b/pkg/msvc/msvc-2013/RetroArch-msvc2013.vcxproj @@ -84,7 +84,7 @@ Level3 Disabled - WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_MENU;HAVE_SLANG;HAVE_GLSLANG;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;_DEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;%(PreprocessorDefinitions) + WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_MENU;HAVE_SLANG;HAVE_GLSLANG;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;_DEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;ENABLE_HLSL;%(PreprocessorDefinitions) $(SolutionDir)\..\..\gfx\include\dxsdk;$(SolutionDir)\..\..\gfx\include;$(SolutionDir)\..\..\libretro-common\include;$(SolutionDir)\..\..\deps;$(SolutionDir)\..\..\deps\glslang;$(SolutionDir)\..\..\deps\SPIRV-Cross;%(AdditionalIncludeDirectories) OldStyle @@ -100,7 +100,7 @@ Level3 Disabled - WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_MENU;HAVE_SLANG;HAVE_GLSLANG;HAVE_UPDATE_ASSETS;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;_DEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;%(PreprocessorDefinitions) + WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_MENU;HAVE_SLANG;HAVE_GLSLANG;HAVE_UPDATE_ASSETS;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;_DEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;ENABLE_HLSL;%(PreprocessorDefinitions) $(SolutionDir)\..\..\gfx\include\dxsdk;$(SolutionDir)\..\..\gfx\include;$(SolutionDir)\..\..\libretro-common\include;$(SolutionDir)\..\..\deps;$(SolutionDir)\..\..\deps\glslang;$(SolutionDir)\..\..\deps\SPIRV-Cross;%(AdditionalIncludeDirectories) OldStyle @@ -118,7 +118,7 @@ MaxSpeed true true - WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;HAVE_MENU;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;NDEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_COMMAND;HAVE_NETWORK_CMD;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;%(PreprocessorDefinitions) + WIN32;WANT_GLSLANG;HAVE_DYNAMIC;HAVE_DYLIB;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;HAVE_MENU;HAVE_XMB;HAVE_SHADERPIPELINE;HAVE_RGUI;HAVE_MATERIALUI;NDEBUG;_WINDOWS;HAVE_XAUDIO;HAVE_DSOUND;HAVE_DINPUT;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_OPENGL;HAVE_VULKAN;HAVE_GLSL;HAVE_THREADS;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_RJPEG;HAVE_RPNG;HAVE_ZLIB;WANT_ZLIB;HAVE_NETWORKING;HAVE_COMMAND;HAVE_NETWORK_CMD;HAVE_STDIN_CMD;HAVE_OVERLAY;HAVE_7ZIP;HAVE_LIBRETRODB;HAVE_STB_FONT;ENABLE_HLSL;%(PreprocessorDefinitions) $(SolutionDir)\..\..\gfx\include\dxsdk;$(SolutionDir)\..\..\gfx\include;$(SolutionDir)\..\..\libretro-common\include;$(SolutionDir)\..\..\deps;$(SolutionDir)\..\..\deps\glslang;$(SolutionDir)\..\..\deps\SPIRV-Cross;%(AdditionalIncludeDirectories) OldStyle diff --git a/pkg/msvc/msvc-2015/RetroArch-msvc2015.vcxproj b/pkg/msvc/msvc-2015/RetroArch-msvc2015.vcxproj index f58275b30d..c62bb0c16a 100644 --- a/pkg/msvc/msvc-2015/RetroArch-msvc2015.vcxproj +++ b/pkg/msvc/msvc-2015/RetroArch-msvc2015.vcxproj @@ -190,7 +190,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -210,7 +210,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -231,7 +231,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -252,7 +252,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -275,7 +275,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -300,7 +300,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -326,7 +326,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -351,7 +351,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;HAVE_UPDATE_ASSETS;HAVE_SLANG;HAVE_GLSLANG;WANT_GLSLANG;HAVE_VULKAN;HAVE_SPIRV_CROSS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\gfx\include\dxsdk;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -385,4 +385,4 @@ - + \ No newline at end of file diff --git a/pkg/msvc/msvc-2017/RetroArch-msvc2017.vcxproj b/pkg/msvc/msvc-2017/RetroArch-msvc2017.vcxproj index 4898855449..21d43e0a3a 100644 --- a/pkg/msvc/msvc-2017/RetroArch-msvc2017.vcxproj +++ b/pkg/msvc/msvc-2017/RetroArch-msvc2017.vcxproj @@ -371,7 +371,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -391,7 +391,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -412,7 +412,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -433,7 +433,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -454,7 +454,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -474,7 +474,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -495,7 +495,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -516,7 +516,7 @@ Level3 Disabled - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_FBO;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_DEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreadedDebug CompileAsCpp @@ -539,7 +539,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -564,7 +564,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -590,7 +590,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -616,7 +616,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;_CRT_NONSTDC_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;__SSE__;__i686__;HAVE_OVERLAY;HAVE_MENU;HAVE_RGUI;HAVE_GL_SYNC;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -642,7 +642,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -667,7 +667,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -693,7 +693,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp @@ -719,7 +719,7 @@ MaxSpeed true true - WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT + WIN32;RARCH_INTERNAL;HAVE_CC_RESAMPLER;WANT_GLSLANG;HAVE_SLANG;HAVE_GLSLANG;HAVE_SPIRV_CROSS;HAVE_UPDATE_ASSETS;HAVE_D3D;HAVE_D3D9;HAVE_D3D10;HAVE_D3D11;HAVE_D3D12;HAVE_VULKAN;ENABLE_HLSL;HAVE_CG;HAVE_GLSL;HAVE_CHEEVOS;HAVE_RUNAHEAD;HAVE_GRIFFIN;HAVE_LANGEXTRA;HAVE_FBO;HAVE_ZLIB;HAVE_QT;QT_WIDGETS_LIB;QT_GUI_LIB;QT_CORE_LIB;HAVE_XMB;HAVE_SHADERPIPELINE;WANT_ZLIB;NDEBUG;_WINDOWS;%(PreprocessorDefinitions);HAVE_DINPUT;HAVE_XINPUT;HAVE_XAUDIO;HAVE_DSOUND;HAVE_OPENGL;HAVE_DYLIB;HAVE_NETWORKING;HAVE_NETWORK_CMD;HAVE_COMMAND;HAVE_STDIN_CMD;HAVE_THREADS;HAVE_DYNAMIC;HAVE_RPNG;HAVE_RJPEG;HAVE_RBMP;HAVE_RTGA;HAVE_IMAGEVIEWER;WANT_ZLIB;_CRT_SECURE_NO_WARNINGS;__SSE__;__SSE2__;__x86_64__;HAVE_OVERLAY;HAVE_RGUI;HAVE_GL_SYNC;HAVE_MENU;HAVE_7ZIP;HAVE_MATERIALUI;HAVE_LIBRETRODB;HAVE_STB_FONT $(MSBuildProjectDirectory);$(MSBuildProjectDirectory)\..\..\..\;$(CG_INC_PATH);$(MSBuildProjectDirectory)\..\..\..\deps\zlib;$(MSBuildProjectDirectory)\..\..\..\libretro-common\include;$(MSBuildProjectDirectory)\..\..\..\deps;$(MSBuildProjectDirectory)\..\..\..\deps\glslang;$(MSBuildProjectDirectory)\..\..\..\deps\SPIRV-Cross;$(MSBuildProjectDirectory)\..\..\..\deps\stb;$(MSBuildProjectDirectory)\..\..\..\gfx\include;%(AdditionalIncludeDirectories) MultiThreaded CompileAsCpp