mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-01-29 00:32:49 +00:00
Code Issues Packages Projects Releases Wiki Activity
RetroArch/deps/glslang/glslang.diff
twinaphex f8cad6f565 Update glslang
2018-06-20 10:47:08 +02:00

4180 lines
210 KiB
Diff
Raw Blame History

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<const char*, int, str_hash, str_eq>* 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<TParseContextBase> parseContext(CreateParseContext(symbolTable, intermediate, version, profile, source,
+ std::unique_ptr<TParseContextBase> _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<TParseContextBase> parseContext(CreateParseContext(*symbolTable, intermediate, version, profile, source,
+ std::unique_ptr<TParseContextBase> _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<glslang::TString>& 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 <windows.h>
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<TFunctionDeclarator> 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<HlslToken>* 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<HlslToken>& 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<const char*, glslang::EHlslTokenClass, str_hash, str_eq>* KeywordMap = nullptr;
-std::unordered_set<const char*, str_hash, str_eq>* ReservedSet = nullptr;
-std::unordered_map<const char*, glslang::TBuiltInVariable, str_hash, str_eq>* SemanticMap = nullptr;
+std::unordered_map<const char*, glslang::EHlslTokenClass, str_hash, str_eq>* hlslKeywordMap = nullptr;
+std::unordered_set<const char*, str_hash, str_eq>* hlslReservedSet = nullptr;
+std::unordered_map<const char*, glslang::TBuiltInVariable, str_hash, str_eq>* 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<const char*, EHlslTokenClass, str_hash, str_eq>;
-
- (*KeywordMap)["static"] = EHTokStatic;
- (*KeywordMap)["const"] = EHTokConst;
- (*KeywordMap)["unorm"] = EHTokUnorm;
- (*KeywordMap)["snorm"] = EHTokSNorm;
- (*KeywordMap)["extern"] = EHTokExtern;
- (*KeywordMap)["uniform"] = EHTokUniform;
- (*KeywordMap)["volatile"] = EHTokVolatile;
- (*KeywordMap)["precise"] = EHTokPrecise;
- (*KeywordMap)["shared"] = EHTokShared;
- (*KeywordMap)["groupshared"] = EHTokGroupShared;
- (*KeywordMap)["linear"] = EHTokLinear;
- (*KeywordMap)["centroid"] = EHTokCentroid;
- (*KeywordMap)["nointerpolation"] = EHTokNointerpolation;
- (*KeywordMap)["noperspective"] = EHTokNoperspective;
- (*KeywordMap)["sample"] = EHTokSample;
- (*KeywordMap)["row_major"] = EHTokRowMajor;
- (*KeywordMap)["column_major"] = EHTokColumnMajor;
- (*KeywordMap)["packoffset"] = EHTokPackOffset;
- (*KeywordMap)["in"] = EHTokIn;
- (*KeywordMap)["out"] = EHTokOut;
- (*KeywordMap)["inout"] = EHTokInOut;
- (*KeywordMap)["layout"] = EHTokLayout;
- (*KeywordMap)["globallycoherent"] = EHTokGloballyCoherent;
- (*KeywordMap)["inline"] = EHTokInline;
-
- (*KeywordMap)["point"] = EHTokPoint;
- (*KeywordMap)["line"] = EHTokLine;
- (*KeywordMap)["triangle"] = EHTokTriangle;
- (*KeywordMap)["lineadj"] = EHTokLineAdj;
- (*KeywordMap)["triangleadj"] = EHTokTriangleAdj;
-
- (*KeywordMap)["PointStream"] = EHTokPointStream;
- (*KeywordMap)["LineStream"] = EHTokLineStream;
- (*KeywordMap)["TriangleStream"] = EHTokTriangleStream;
-
- (*KeywordMap)["InputPatch"] = EHTokInputPatch;
- (*KeywordMap)["OutputPatch"] = EHTokOutputPatch;
-
- (*KeywordMap)["Buffer"] = EHTokBuffer;
- (*KeywordMap)["vector"] = EHTokVector;
- (*KeywordMap)["matrix"] = EHTokMatrix;
-
- (*KeywordMap)["void"] = EHTokVoid;
- (*KeywordMap)["string"] = EHTokString;
- (*KeywordMap)["bool"] = EHTokBool;
- (*KeywordMap)["int"] = EHTokInt;
- (*KeywordMap)["uint"] = EHTokUint;
- (*KeywordMap)["uint64_t"] = EHTokUint64;
- (*KeywordMap)["dword"] = EHTokDword;
- (*KeywordMap)["half"] = EHTokHalf;
- (*KeywordMap)["float"] = EHTokFloat;
- (*KeywordMap)["double"] = EHTokDouble;
- (*KeywordMap)["min16float"] = EHTokMin16float;
- (*KeywordMap)["min10float"] = EHTokMin10float;
- (*KeywordMap)["min16int"] = EHTokMin16int;
- (*KeywordMap)["min12int"] = EHTokMin12int;
- (*KeywordMap)["min16uint"] = EHTokMin16uint;
-
- (*KeywordMap)["bool1"] = EHTokBool1;
- (*KeywordMap)["bool2"] = EHTokBool2;
- (*KeywordMap)["bool3"] = EHTokBool3;
- (*KeywordMap)["bool4"] = EHTokBool4;
- (*KeywordMap)["float1"] = EHTokFloat1;
- (*KeywordMap)["float2"] = EHTokFloat2;
- (*KeywordMap)["float3"] = EHTokFloat3;
- (*KeywordMap)["float4"] = EHTokFloat4;
- (*KeywordMap)["int1"] = EHTokInt1;
- (*KeywordMap)["int2"] = EHTokInt2;
- (*KeywordMap)["int3"] = EHTokInt3;
- (*KeywordMap)["int4"] = EHTokInt4;
- (*KeywordMap)["double1"] = EHTokDouble1;
- (*KeywordMap)["double2"] = EHTokDouble2;
- (*KeywordMap)["double3"] = EHTokDouble3;
- (*KeywordMap)["double4"] = EHTokDouble4;
- (*KeywordMap)["uint1"] = EHTokUint1;
- (*KeywordMap)["uint2"] = EHTokUint2;
- (*KeywordMap)["uint3"] = EHTokUint3;
- (*KeywordMap)["uint4"] = EHTokUint4;
-
- (*KeywordMap)["half1"] = EHTokHalf1;
- (*KeywordMap)["half2"] = EHTokHalf2;
- (*KeywordMap)["half3"] = EHTokHalf3;
- (*KeywordMap)["half4"] = EHTokHalf4;
- (*KeywordMap)["min16float1"] = EHTokMin16float1;
- (*KeywordMap)["min16float2"] = EHTokMin16float2;
- (*KeywordMap)["min16float3"] = EHTokMin16float3;
- (*KeywordMap)["min16float4"] = EHTokMin16float4;
- (*KeywordMap)["min10float1"] = EHTokMin10float1;
- (*KeywordMap)["min10float2"] = EHTokMin10float2;
- (*KeywordMap)["min10float3"] = EHTokMin10float3;
- (*KeywordMap)["min10float4"] = EHTokMin10float4;
- (*KeywordMap)["min16int1"] = EHTokMin16int1;
- (*KeywordMap)["min16int2"] = EHTokMin16int2;
- (*KeywordMap)["min16int3"] = EHTokMin16int3;
- (*KeywordMap)["min16int4"] = EHTokMin16int4;
- (*KeywordMap)["min12int1"] = EHTokMin12int1;
- (*KeywordMap)["min12int2"] = EHTokMin12int2;
- (*KeywordMap)["min12int3"] = EHTokMin12int3;
- (*KeywordMap)["min12int4"] = EHTokMin12int4;
- (*KeywordMap)["min16uint1"] = EHTokMin16uint1;
- (*KeywordMap)["min16uint2"] = EHTokMin16uint2;
- (*KeywordMap)["min16uint3"] = EHTokMin16uint3;
- (*KeywordMap)["min16uint4"] = EHTokMin16uint4;
-
- (*KeywordMap)["bool1x1"] = EHTokBool1x1;
- (*KeywordMap)["bool1x2"] = EHTokBool1x2;
- (*KeywordMap)["bool1x3"] = EHTokBool1x3;
- (*KeywordMap)["bool1x4"] = EHTokBool1x4;
- (*KeywordMap)["bool2x1"] = EHTokBool2x1;
- (*KeywordMap)["bool2x2"] = EHTokBool2x2;
- (*KeywordMap)["bool2x3"] = EHTokBool2x3;
- (*KeywordMap)["bool2x4"] = EHTokBool2x4;
- (*KeywordMap)["bool3x1"] = EHTokBool3x1;
- (*KeywordMap)["bool3x2"] = EHTokBool3x2;
- (*KeywordMap)["bool3x3"] = EHTokBool3x3;
- (*KeywordMap)["bool3x4"] = EHTokBool3x4;
- (*KeywordMap)["bool4x1"] = EHTokBool4x1;
- (*KeywordMap)["bool4x2"] = EHTokBool4x2;
- (*KeywordMap)["bool4x3"] = EHTokBool4x3;
- (*KeywordMap)["bool4x4"] = EHTokBool4x4;
- (*KeywordMap)["int1x1"] = EHTokInt1x1;
- (*KeywordMap)["int1x2"] = EHTokInt1x2;
- (*KeywordMap)["int1x3"] = EHTokInt1x3;
- (*KeywordMap)["int1x4"] = EHTokInt1x4;
- (*KeywordMap)["int2x1"] = EHTokInt2x1;
- (*KeywordMap)["int2x2"] = EHTokInt2x2;
- (*KeywordMap)["int2x3"] = EHTokInt2x3;
- (*KeywordMap)["int2x4"] = EHTokInt2x4;
- (*KeywordMap)["int3x1"] = EHTokInt3x1;
- (*KeywordMap)["int3x2"] = EHTokInt3x2;
- (*KeywordMap)["int3x3"] = EHTokInt3x3;
- (*KeywordMap)["int3x4"] = EHTokInt3x4;
- (*KeywordMap)["int4x1"] = EHTokInt4x1;
- (*KeywordMap)["int4x2"] = EHTokInt4x2;
- (*KeywordMap)["int4x3"] = EHTokInt4x3;
- (*KeywordMap)["int4x4"] = EHTokInt4x4;
- (*KeywordMap)["uint1x1"] = EHTokUint1x1;
- (*KeywordMap)["uint1x2"] = EHTokUint1x2;
- (*KeywordMap)["uint1x3"] = EHTokUint1x3;
- (*KeywordMap)["uint1x4"] = EHTokUint1x4;
- (*KeywordMap)["uint2x1"] = EHTokUint2x1;
- (*KeywordMap)["uint2x2"] = EHTokUint2x2;
- (*KeywordMap)["uint2x3"] = EHTokUint2x3;
- (*KeywordMap)["uint2x4"] = EHTokUint2x4;
- (*KeywordMap)["uint3x1"] = EHTokUint3x1;
- (*KeywordMap)["uint3x2"] = EHTokUint3x2;
- (*KeywordMap)["uint3x3"] = EHTokUint3x3;
- (*KeywordMap)["uint3x4"] = EHTokUint3x4;
- (*KeywordMap)["uint4x1"] = EHTokUint4x1;
- (*KeywordMap)["uint4x2"] = EHTokUint4x2;
- (*KeywordMap)["uint4x3"] = EHTokUint4x3;
- (*KeywordMap)["uint4x4"] = EHTokUint4x4;
- (*KeywordMap)["bool1x1"] = EHTokBool1x1;
- (*KeywordMap)["bool1x2"] = EHTokBool1x2;
- (*KeywordMap)["bool1x3"] = EHTokBool1x3;
- (*KeywordMap)["bool1x4"] = EHTokBool1x4;
- (*KeywordMap)["bool2x1"] = EHTokBool2x1;
- (*KeywordMap)["bool2x2"] = EHTokBool2x2;
- (*KeywordMap)["bool2x3"] = EHTokBool2x3;
- (*KeywordMap)["bool2x4"] = EHTokBool2x4;
- (*KeywordMap)["bool3x1"] = EHTokBool3x1;
- (*KeywordMap)["bool3x2"] = EHTokBool3x2;
- (*KeywordMap)["bool3x3"] = EHTokBool3x3;
- (*KeywordMap)["bool3x4"] = EHTokBool3x4;
- (*KeywordMap)["bool4x1"] = EHTokBool4x1;
- (*KeywordMap)["bool4x2"] = EHTokBool4x2;
- (*KeywordMap)["bool4x3"] = EHTokBool4x3;
- (*KeywordMap)["bool4x4"] = EHTokBool4x4;
- (*KeywordMap)["float1x1"] = EHTokFloat1x1;
- (*KeywordMap)["float1x2"] = EHTokFloat1x2;
- (*KeywordMap)["float1x3"] = EHTokFloat1x3;
- (*KeywordMap)["float1x4"] = EHTokFloat1x4;
- (*KeywordMap)["float2x1"] = EHTokFloat2x1;
- (*KeywordMap)["float2x2"] = EHTokFloat2x2;
- (*KeywordMap)["float2x3"] = EHTokFloat2x3;
- (*KeywordMap)["float2x4"] = EHTokFloat2x4;
- (*KeywordMap)["float3x1"] = EHTokFloat3x1;
- (*KeywordMap)["float3x2"] = EHTokFloat3x2;
- (*KeywordMap)["float3x3"] = EHTokFloat3x3;
- (*KeywordMap)["float3x4"] = EHTokFloat3x4;
- (*KeywordMap)["float4x1"] = EHTokFloat4x1;
- (*KeywordMap)["float4x2"] = EHTokFloat4x2;
- (*KeywordMap)["float4x3"] = EHTokFloat4x3;
- (*KeywordMap)["float4x4"] = EHTokFloat4x4;
- (*KeywordMap)["half1x1"] = EHTokHalf1x1;
- (*KeywordMap)["half1x2"] = EHTokHalf1x2;
- (*KeywordMap)["half1x3"] = EHTokHalf1x3;
- (*KeywordMap)["half1x4"] = EHTokHalf1x4;
- (*KeywordMap)["half2x1"] = EHTokHalf2x1;
- (*KeywordMap)["half2x2"] = EHTokHalf2x2;
- (*KeywordMap)["half2x3"] = EHTokHalf2x3;
- (*KeywordMap)["half2x4"] = EHTokHalf2x4;
- (*KeywordMap)["half3x1"] = EHTokHalf3x1;
- (*KeywordMap)["half3x2"] = EHTokHalf3x2;
- (*KeywordMap)["half3x3"] = EHTokHalf3x3;
- (*KeywordMap)["half3x4"] = EHTokHalf3x4;
- (*KeywordMap)["half4x1"] = EHTokHalf4x1;
- (*KeywordMap)["half4x2"] = EHTokHalf4x2;
- (*KeywordMap)["half4x3"] = EHTokHalf4x3;
- (*KeywordMap)["half4x4"] = EHTokHalf4x4;
- (*KeywordMap)["double1x1"] = EHTokDouble1x1;
- (*KeywordMap)["double1x2"] = EHTokDouble1x2;
- (*KeywordMap)["double1x3"] = EHTokDouble1x3;
- (*KeywordMap)["double1x4"] = EHTokDouble1x4;
- (*KeywordMap)["double2x1"] = EHTokDouble2x1;
- (*KeywordMap)["double2x2"] = EHTokDouble2x2;
- (*KeywordMap)["double2x3"] = EHTokDouble2x3;
- (*KeywordMap)["double2x4"] = EHTokDouble2x4;
- (*KeywordMap)["double3x1"] = EHTokDouble3x1;
- (*KeywordMap)["double3x2"] = EHTokDouble3x2;
- (*KeywordMap)["double3x3"] = EHTokDouble3x3;
- (*KeywordMap)["double3x4"] = EHTokDouble3x4;
- (*KeywordMap)["double4x1"] = EHTokDouble4x1;
- (*KeywordMap)["double4x2"] = EHTokDouble4x2;
- (*KeywordMap)["double4x3"] = EHTokDouble4x3;
- (*KeywordMap)["double4x4"] = EHTokDouble4x4;
-
- (*KeywordMap)["sampler"] = EHTokSampler;
- (*KeywordMap)["sampler1D"] = EHTokSampler1d;
- (*KeywordMap)["sampler2D"] = EHTokSampler2d;
- (*KeywordMap)["sampler3D"] = EHTokSampler3d;
- (*KeywordMap)["samplerCube"] = EHTokSamplerCube;
- (*KeywordMap)["sampler_state"] = EHTokSamplerState;
- (*KeywordMap)["SamplerState"] = EHTokSamplerState;
- (*KeywordMap)["SamplerComparisonState"] = EHTokSamplerComparisonState;
- (*KeywordMap)["texture"] = EHTokTexture;
- (*KeywordMap)["Texture1D"] = EHTokTexture1d;
- (*KeywordMap)["Texture1DArray"] = EHTokTexture1darray;
- (*KeywordMap)["Texture2D"] = EHTokTexture2d;
- (*KeywordMap)["Texture2DArray"] = EHTokTexture2darray;
- (*KeywordMap)["Texture3D"] = EHTokTexture3d;
- (*KeywordMap)["TextureCube"] = EHTokTextureCube;
- (*KeywordMap)["TextureCubeArray"] = EHTokTextureCubearray;
- (*KeywordMap)["Texture2DMS"] = EHTokTexture2DMS;
- (*KeywordMap)["Texture2DMSArray"] = EHTokTexture2DMSarray;
- (*KeywordMap)["RWTexture1D"] = EHTokRWTexture1d;
- (*KeywordMap)["RWTexture1DArray"] = EHTokRWTexture1darray;
- (*KeywordMap)["RWTexture2D"] = EHTokRWTexture2d;
- (*KeywordMap)["RWTexture2DArray"] = EHTokRWTexture2darray;
- (*KeywordMap)["RWTexture3D"] = EHTokRWTexture3d;
- (*KeywordMap)["RWBuffer"] = EHTokRWBuffer;
- (*KeywordMap)["SubpassInput"] = EHTokSubpassInput;
- (*KeywordMap)["SubpassInputMS"] = EHTokSubpassInputMS;
-
- (*KeywordMap)["AppendStructuredBuffer"] = EHTokAppendStructuredBuffer;
- (*KeywordMap)["ByteAddressBuffer"] = EHTokByteAddressBuffer;
- (*KeywordMap)["ConsumeStructuredBuffer"] = EHTokConsumeStructuredBuffer;
- (*KeywordMap)["RWByteAddressBuffer"] = EHTokRWByteAddressBuffer;
- (*KeywordMap)["RWStructuredBuffer"] = EHTokRWStructuredBuffer;
- (*KeywordMap)["StructuredBuffer"] = EHTokStructuredBuffer;
- (*KeywordMap)["TextureBuffer"] = EHTokTextureBuffer;
-
- (*KeywordMap)["class"] = EHTokClass;
- (*KeywordMap)["struct"] = EHTokStruct;
- (*KeywordMap)["cbuffer"] = EHTokCBuffer;
- (*KeywordMap)["ConstantBuffer"] = EHTokConstantBuffer;
- (*KeywordMap)["tbuffer"] = EHTokTBuffer;
- (*KeywordMap)["typedef"] = EHTokTypedef;
- (*KeywordMap)["this"] = EHTokThis;
- (*KeywordMap)["namespace"] = EHTokNamespace;
-
- (*KeywordMap)["true"] = EHTokBoolConstant;
- (*KeywordMap)["false"] = EHTokBoolConstant;
-
- (*KeywordMap)["for"] = EHTokFor;
- (*KeywordMap)["do"] = EHTokDo;
- (*KeywordMap)["while"] = EHTokWhile;
- (*KeywordMap)["break"] = EHTokBreak;
- (*KeywordMap)["continue"] = EHTokContinue;
- (*KeywordMap)["if"] = EHTokIf;
- (*KeywordMap)["else"] = EHTokElse;
- (*KeywordMap)["discard"] = EHTokDiscard;
- (*KeywordMap)["return"] = EHTokReturn;
- (*KeywordMap)["switch"] = EHTokSwitch;
- (*KeywordMap)["case"] = EHTokCase;
- (*KeywordMap)["default"] = EHTokDefault;
+ hlslKeywordMap = new std::unordered_map<const char*, EHlslTokenClass, str_hash, str_eq>;
+
+ (*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<const char*, str_hash, str_eq>;
-
- ReservedSet->insert("auto");
- ReservedSet->insert("catch");
- ReservedSet->insert("char");
- ReservedSet->insert("const_cast");
- ReservedSet->insert("enum");
- ReservedSet->insert("explicit");
- ReservedSet->insert("friend");
- ReservedSet->insert("goto");
- ReservedSet->insert("long");
- ReservedSet->insert("mutable");
- ReservedSet->insert("new");
- ReservedSet->insert("operator");
- ReservedSet->insert("private");
- ReservedSet->insert("protected");
- ReservedSet->insert("public");
- ReservedSet->insert("reinterpret_cast");
- ReservedSet->insert("short");
- ReservedSet->insert("signed");
- ReservedSet->insert("sizeof");
- ReservedSet->insert("static_cast");
- ReservedSet->insert("template");
- ReservedSet->insert("throw");
- ReservedSet->insert("try");
- ReservedSet->insert("typename");
- ReservedSet->insert("union");
- ReservedSet->insert("unsigned");
- ReservedSet->insert("using");
- ReservedSet->insert("virtual");
-
- SemanticMap = new std::unordered_map<const char*, glslang::TBuiltInVariable, str_hash, str_eq>;
+ hlslReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
+
+ 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<const char*, glslang::TBuiltInVariable, str_hash, str_eq>;
// in DX9, all outputs had to have a semantic associated with them, that was either consumed
// by the system or was a specific register assignment
@@ -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;
Reference in New Issue View Git Blame Copy Permalink