• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
3 // Copyright (C) 2013 LunarG, Inc.
4 // Copyright (C) 2017 ARM Limited.
5 //
6 // All rights reserved.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions
10 // are met:
11 //
12 //    Redistributions of source code must retain the above copyright
13 //    notice, this list of conditions and the following disclaimer.
14 //
15 //    Redistributions in binary form must reproduce the above
16 //    copyright notice, this list of conditions and the following
17 //    disclaimer in the documentation and/or other materials provided
18 //    with the distribution.
19 //
20 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
21 //    contributors may be used to endorse or promote products derived
22 //    from this software without specific prior written permission.
23 //
24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 // POSSIBILITY OF SUCH DAMAGE.
36 //
37 
38 //
39 // GLSL scanning, leveraging the scanning done by the preprocessor.
40 //
41 
42 #include <cstring>
43 #include <unordered_map>
44 #include <unordered_set>
45 
46 #include "../Include/Types.h"
47 #include "SymbolTable.h"
48 #include "ParseHelper.h"
49 #include "attribute.h"
50 #include "glslang_tab.cpp.h"
51 #include "ScanContext.h"
52 #include "Scan.h"
53 
54 // preprocessor includes
55 #include "preprocessor/PpContext.h"
56 #include "preprocessor/PpTokens.h"
57 
58 // Required to avoid missing prototype warnings for some compilers
59 int yylex(YYSTYPE*, glslang::TParseContext&);
60 
61 namespace glslang {
62 
63 // read past any white space
consumeWhiteSpace(bool & foundNonSpaceTab)64 void TInputScanner::consumeWhiteSpace(bool& foundNonSpaceTab)
65 {
66     int c = peek();  // don't accidentally consume anything other than whitespace
67     while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
68         if (c == '\r' || c == '\n')
69             foundNonSpaceTab = true;
70         get();
71         c = peek();
72     }
73 }
74 
75 // return true if a comment was actually consumed
consumeComment()76 bool TInputScanner::consumeComment()
77 {
78     if (peek() != '/')
79         return false;
80 
81     get();  // consume the '/'
82     int c = peek();
83     if (c == '/') {
84 
85         // a '//' style comment
86         get();  // consume the second '/'
87         c = get();
88         do {
89             while (c != EndOfInput && c != '\\' && c != '\r' && c != '\n')
90                 c = get();
91 
92             if (c == EndOfInput || c == '\r' || c == '\n') {
93                 while (c == '\r' || c == '\n')
94                     c = get();
95 
96                 // we reached the end of the comment
97                 break;
98             } else {
99                 // it's a '\', so we need to keep going, after skipping what's escaped
100 
101                 // read the skipped character
102                 c = get();
103 
104                 // if it's a two-character newline, skip both characters
105                 if (c == '\r' && peek() == '\n')
106                     get();
107                 c = get();
108             }
109         } while (true);
110 
111         // put back the last non-comment character
112         if (c != EndOfInput)
113             unget();
114 
115         return true;
116     } else if (c == '*') {
117 
118         // a '/*' style comment
119         get();  // consume the '*'
120         c = get();
121         do {
122             while (c != EndOfInput && c != '*')
123                 c = get();
124             if (c == '*') {
125                 c = get();
126                 if (c == '/')
127                     break;  // end of comment
128                 // not end of comment
129             } else // end of input
130                 break;
131         } while (true);
132 
133         return true;
134     } else {
135         // it's not a comment, put the '/' back
136         unget();
137 
138         return false;
139     }
140 }
141 
142 // skip whitespace, then skip a comment, rinse, repeat
consumeWhitespaceComment(bool & foundNonSpaceTab)143 void TInputScanner::consumeWhitespaceComment(bool& foundNonSpaceTab)
144 {
145     do {
146         consumeWhiteSpace(foundNonSpaceTab);
147 
148         // if not starting a comment now, then done
149         int c = peek();
150         if (c != '/' || c == EndOfInput)
151             return;
152 
153         // skip potential comment
154         foundNonSpaceTab = true;
155         if (! consumeComment())
156             return;
157 
158     } while (true);
159 }
160 
161 // Returns true if there was non-white space (e.g., a comment, newline) before the #version
162 // or no #version was found; otherwise, returns false.  There is no error case, it always
163 // succeeds, but will leave version == 0 if no #version was found.
164 //
165 // Sets notFirstToken based on whether tokens (beyond white space and comments)
166 // appeared before the #version.
167 //
168 // N.B. does not attempt to leave input in any particular known state.  The assumption
169 // is that scanning will start anew, following the rules for the chosen version/profile,
170 // and with a corresponding parsing context.
171 //
scanVersion(int & version,EProfile & profile,bool & notFirstToken)172 bool TInputScanner::scanVersion(int& version, EProfile& profile, bool& notFirstToken)
173 {
174     // This function doesn't have to get all the semantics correct,
175     // just find the #version if there is a correct one present.
176     // The preprocessor will have the responsibility of getting all the semantics right.
177 
178     bool versionNotFirst = false;  // means not first WRT comments and white space, nothing more
179     notFirstToken = false;         // means not first WRT to real tokens
180     version = 0;                   // means not found
181     profile = ENoProfile;
182 
183     bool foundNonSpaceTab = false;
184     bool lookingInMiddle = false;
185     int c;
186     do {
187         if (lookingInMiddle) {
188             notFirstToken = true;
189             // make forward progress by finishing off the current line plus extra new lines
190             if (peek() == '\n' || peek() == '\r') {
191                 while (peek() == '\n' || peek() == '\r')
192                     get();
193             } else
194                 do {
195                     c = get();
196                 } while (c != EndOfInput && c != '\n' && c != '\r');
197                 while (peek() == '\n' || peek() == '\r')
198                     get();
199                 if (peek() == EndOfInput)
200                     return true;
201         }
202         lookingInMiddle = true;
203 
204         // Nominal start, skipping the desktop allowed comments and white space, but tracking if
205         // something else was found for ES:
206         consumeWhitespaceComment(foundNonSpaceTab);
207         if (foundNonSpaceTab)
208             versionNotFirst = true;
209 
210         // "#"
211         if (get() != '#') {
212             versionNotFirst = true;
213             continue;
214         }
215 
216         // whitespace
217         do {
218             c = get();
219         } while (c == ' ' || c == '\t');
220 
221         // "version"
222         if (    c != 'v' ||
223             get() != 'e' ||
224             get() != 'r' ||
225             get() != 's' ||
226             get() != 'i' ||
227             get() != 'o' ||
228             get() != 'n') {
229             versionNotFirst = true;
230             continue;
231         }
232 
233         // whitespace
234         do {
235             c = get();
236         } while (c == ' ' || c == '\t');
237 
238         // version number
239         while (c >= '0' && c <= '9') {
240             version = 10 * version + (c - '0');
241             c = get();
242         }
243         if (version == 0) {
244             versionNotFirst = true;
245             continue;
246         }
247 
248         // whitespace
249         while (c == ' ' || c == '\t')
250             c = get();
251 
252         // profile
253         const int maxProfileLength = 13;  // not including any 0
254         char profileString[maxProfileLength];
255         int profileLength;
256         for (profileLength = 0; profileLength < maxProfileLength; ++profileLength) {
257             if (c == EndOfInput || c == ' ' || c == '\t' || c == '\n' || c == '\r')
258                 break;
259             profileString[profileLength] = (char)c;
260             c = get();
261         }
262         if (c != EndOfInput && c != ' ' && c != '\t' && c != '\n' && c != '\r') {
263             versionNotFirst = true;
264             continue;
265         }
266 
267         if (profileLength == 2 && strncmp(profileString, "es", profileLength) == 0)
268             profile = EEsProfile;
269         else if (profileLength == 4 && strncmp(profileString, "core", profileLength) == 0)
270             profile = ECoreProfile;
271         else if (profileLength == 13 && strncmp(profileString, "compatibility", profileLength) == 0)
272             profile = ECompatibilityProfile;
273 
274         return versionNotFirst;
275     } while (true);
276 }
277 
278 // Fill this in when doing glslang-level scanning, to hand back to the parser.
279 class TParserToken {
280 public:
TParserToken(YYSTYPE & b)281     explicit TParserToken(YYSTYPE& b) : sType(b) { }
282 
283     YYSTYPE& sType;
284 protected:
285     TParserToken(TParserToken&);
286     TParserToken& operator=(TParserToken&);
287 };
288 
289 } // end namespace glslang
290 
291 // This is the function the glslang parser (i.e., bison) calls to get its next token
yylex(YYSTYPE * glslangTokenDesc,glslang::TParseContext & parseContext)292 int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& parseContext)
293 {
294     glslang::TParserToken token(*glslangTokenDesc);
295 
296     return parseContext.getScanContext()->tokenize(parseContext.getPpContext(), token);
297 }
298 
299 namespace {
300 
301 struct str_eq
302 {
operator ()__anoncf4ae2820111::str_eq303     bool operator()(const char* lhs, const char* rhs) const
304     {
305         return strcmp(lhs, rhs) == 0;
306     }
307 };
308 
309 struct str_hash
310 {
operator ()__anoncf4ae2820111::str_hash311     size_t operator()(const char* str) const
312     {
313         // djb2
314         unsigned long hash = 5381;
315         int c;
316 
317         while ((c = *str++) != 0)
318             hash = ((hash << 5) + hash) + c;
319 
320         return hash;
321     }
322 };
323 
324 // A single global usable by all threads, by all versions, by all languages.
325 // After a single process-level initialization, this is read only and thread safe
326 std::unordered_map<const char*, int, str_hash, str_eq>* KeywordMap = nullptr;
327 std::unordered_set<const char*, str_hash, str_eq>* ReservedSet = nullptr;
328 
329 };
330 
331 namespace glslang {
332 
fillInKeywordMap()333 void TScanContext::fillInKeywordMap()
334 {
335     if (KeywordMap != nullptr) {
336         // this is really an error, as this should called only once per process
337         // but, the only risk is if two threads called simultaneously
338         return;
339     }
340     KeywordMap = new std::unordered_map<const char*, int, str_hash, str_eq>;
341 
342     (*KeywordMap)["const"] =                   CONST;
343     (*KeywordMap)["uniform"] =                 UNIFORM;
344     (*KeywordMap)["nonuniformEXT"] =           NONUNIFORM;
345     (*KeywordMap)["in"] =                      IN;
346     (*KeywordMap)["out"] =                     OUT;
347     (*KeywordMap)["inout"] =                   INOUT;
348     (*KeywordMap)["struct"] =                  STRUCT;
349     (*KeywordMap)["break"] =                   BREAK;
350     (*KeywordMap)["continue"] =                CONTINUE;
351     (*KeywordMap)["do"] =                      DO;
352     (*KeywordMap)["for"] =                     FOR;
353     (*KeywordMap)["while"] =                   WHILE;
354     (*KeywordMap)["switch"] =                  SWITCH;
355     (*KeywordMap)["case"] =                    CASE;
356     (*KeywordMap)["default"] =                 DEFAULT;
357     (*KeywordMap)["if"] =                      IF;
358     (*KeywordMap)["else"] =                    ELSE;
359     (*KeywordMap)["discard"] =                 DISCARD;
360     (*KeywordMap)["return"] =                  RETURN;
361     (*KeywordMap)["void"] =                    VOID;
362     (*KeywordMap)["bool"] =                    BOOL;
363     (*KeywordMap)["float"] =                   FLOAT;
364     (*KeywordMap)["int"] =                     INT;
365     (*KeywordMap)["bvec2"] =                   BVEC2;
366     (*KeywordMap)["bvec3"] =                   BVEC3;
367     (*KeywordMap)["bvec4"] =                   BVEC4;
368     (*KeywordMap)["vec2"] =                    VEC2;
369     (*KeywordMap)["vec3"] =                    VEC3;
370     (*KeywordMap)["vec4"] =                    VEC4;
371     (*KeywordMap)["ivec2"] =                   IVEC2;
372     (*KeywordMap)["ivec3"] =                   IVEC3;
373     (*KeywordMap)["ivec4"] =                   IVEC4;
374     (*KeywordMap)["mat2"] =                    MAT2;
375     (*KeywordMap)["mat3"] =                    MAT3;
376     (*KeywordMap)["mat4"] =                    MAT4;
377     (*KeywordMap)["true"] =                    BOOLCONSTANT;
378     (*KeywordMap)["false"] =                   BOOLCONSTANT;
379     (*KeywordMap)["attribute"] =               ATTRIBUTE;
380     (*KeywordMap)["varying"] =                 VARYING;
381     (*KeywordMap)["buffer"] =                  BUFFER;
382     (*KeywordMap)["coherent"] =                COHERENT;
383     (*KeywordMap)["devicecoherent"] =          DEVICECOHERENT;
384     (*KeywordMap)["queuefamilycoherent"] =     QUEUEFAMILYCOHERENT;
385     (*KeywordMap)["workgroupcoherent"] =       WORKGROUPCOHERENT;
386     (*KeywordMap)["subgroupcoherent"] =        SUBGROUPCOHERENT;
387     (*KeywordMap)["nonprivate"] =              NONPRIVATE;
388     (*KeywordMap)["restrict"] =                RESTRICT;
389     (*KeywordMap)["readonly"] =                READONLY;
390     (*KeywordMap)["writeonly"] =               WRITEONLY;
391     (*KeywordMap)["atomic_uint"] =             ATOMIC_UINT;
392     (*KeywordMap)["volatile"] =                VOLATILE;
393     (*KeywordMap)["layout"] =                  LAYOUT;
394     (*KeywordMap)["shared"] =                  SHARED;
395     (*KeywordMap)["patch"] =                   PATCH;
396     (*KeywordMap)["sample"] =                  SAMPLE;
397     (*KeywordMap)["subroutine"] =              SUBROUTINE;
398     (*KeywordMap)["highp"] =                   HIGH_PRECISION;
399     (*KeywordMap)["mediump"] =                 MEDIUM_PRECISION;
400     (*KeywordMap)["lowp"] =                    LOW_PRECISION;
401     (*KeywordMap)["precision"] =               PRECISION;
402     (*KeywordMap)["mat2x2"] =                  MAT2X2;
403     (*KeywordMap)["mat2x3"] =                  MAT2X3;
404     (*KeywordMap)["mat2x4"] =                  MAT2X4;
405     (*KeywordMap)["mat3x2"] =                  MAT3X2;
406     (*KeywordMap)["mat3x3"] =                  MAT3X3;
407     (*KeywordMap)["mat3x4"] =                  MAT3X4;
408     (*KeywordMap)["mat4x2"] =                  MAT4X2;
409     (*KeywordMap)["mat4x3"] =                  MAT4X3;
410     (*KeywordMap)["mat4x4"] =                  MAT4X4;
411     (*KeywordMap)["dmat2"] =                   DMAT2;
412     (*KeywordMap)["dmat3"] =                   DMAT3;
413     (*KeywordMap)["dmat4"] =                   DMAT4;
414     (*KeywordMap)["dmat2x2"] =                 DMAT2X2;
415     (*KeywordMap)["dmat2x3"] =                 DMAT2X3;
416     (*KeywordMap)["dmat2x4"] =                 DMAT2X4;
417     (*KeywordMap)["dmat3x2"] =                 DMAT3X2;
418     (*KeywordMap)["dmat3x3"] =                 DMAT3X3;
419     (*KeywordMap)["dmat3x4"] =                 DMAT3X4;
420     (*KeywordMap)["dmat4x2"] =                 DMAT4X2;
421     (*KeywordMap)["dmat4x3"] =                 DMAT4X3;
422     (*KeywordMap)["dmat4x4"] =                 DMAT4X4;
423     (*KeywordMap)["image1D"] =                 IMAGE1D;
424     (*KeywordMap)["iimage1D"] =                IIMAGE1D;
425     (*KeywordMap)["uimage1D"] =                UIMAGE1D;
426     (*KeywordMap)["image2D"] =                 IMAGE2D;
427     (*KeywordMap)["iimage2D"] =                IIMAGE2D;
428     (*KeywordMap)["uimage2D"] =                UIMAGE2D;
429     (*KeywordMap)["image3D"] =                 IMAGE3D;
430     (*KeywordMap)["iimage3D"] =                IIMAGE3D;
431     (*KeywordMap)["uimage3D"] =                UIMAGE3D;
432     (*KeywordMap)["image2DRect"] =             IMAGE2DRECT;
433     (*KeywordMap)["iimage2DRect"] =            IIMAGE2DRECT;
434     (*KeywordMap)["uimage2DRect"] =            UIMAGE2DRECT;
435     (*KeywordMap)["imageCube"] =               IMAGECUBE;
436     (*KeywordMap)["iimageCube"] =              IIMAGECUBE;
437     (*KeywordMap)["uimageCube"] =              UIMAGECUBE;
438     (*KeywordMap)["imageBuffer"] =             IMAGEBUFFER;
439     (*KeywordMap)["iimageBuffer"] =            IIMAGEBUFFER;
440     (*KeywordMap)["uimageBuffer"] =            UIMAGEBUFFER;
441     (*KeywordMap)["image1DArray"] =            IMAGE1DARRAY;
442     (*KeywordMap)["iimage1DArray"] =           IIMAGE1DARRAY;
443     (*KeywordMap)["uimage1DArray"] =           UIMAGE1DARRAY;
444     (*KeywordMap)["image2DArray"] =            IMAGE2DARRAY;
445     (*KeywordMap)["iimage2DArray"] =           IIMAGE2DARRAY;
446     (*KeywordMap)["uimage2DArray"] =           UIMAGE2DARRAY;
447     (*KeywordMap)["imageCubeArray"] =          IMAGECUBEARRAY;
448     (*KeywordMap)["iimageCubeArray"] =         IIMAGECUBEARRAY;
449     (*KeywordMap)["uimageCubeArray"] =         UIMAGECUBEARRAY;
450     (*KeywordMap)["image2DMS"] =               IMAGE2DMS;
451     (*KeywordMap)["iimage2DMS"] =              IIMAGE2DMS;
452     (*KeywordMap)["uimage2DMS"] =              UIMAGE2DMS;
453     (*KeywordMap)["image2DMSArray"] =          IMAGE2DMSARRAY;
454     (*KeywordMap)["iimage2DMSArray"] =         IIMAGE2DMSARRAY;
455     (*KeywordMap)["uimage2DMSArray"] =         UIMAGE2DMSARRAY;
456     (*KeywordMap)["double"] =                  DOUBLE;
457     (*KeywordMap)["dvec2"] =                   DVEC2;
458     (*KeywordMap)["dvec3"] =                   DVEC3;
459     (*KeywordMap)["dvec4"] =                   DVEC4;
460     (*KeywordMap)["uint"] =                    UINT;
461     (*KeywordMap)["uvec2"] =                   UVEC2;
462     (*KeywordMap)["uvec3"] =                   UVEC3;
463     (*KeywordMap)["uvec4"] =                   UVEC4;
464 
465     (*KeywordMap)["int64_t"] =                 INT64_T;
466     (*KeywordMap)["uint64_t"] =                UINT64_T;
467     (*KeywordMap)["i64vec2"] =                 I64VEC2;
468     (*KeywordMap)["i64vec3"] =                 I64VEC3;
469     (*KeywordMap)["i64vec4"] =                 I64VEC4;
470     (*KeywordMap)["u64vec2"] =                 U64VEC2;
471     (*KeywordMap)["u64vec3"] =                 U64VEC3;
472     (*KeywordMap)["u64vec4"] =                 U64VEC4;
473 
474     // GL_EXT_shader_explicit_arithmetic_types
475     (*KeywordMap)["int8_t"] =                  INT8_T;
476     (*KeywordMap)["i8vec2"] =                  I8VEC2;
477     (*KeywordMap)["i8vec3"] =                  I8VEC3;
478     (*KeywordMap)["i8vec4"] =                  I8VEC4;
479     (*KeywordMap)["uint8_t"] =                 UINT8_T;
480     (*KeywordMap)["u8vec2"] =                  U8VEC2;
481     (*KeywordMap)["u8vec3"] =                  U8VEC3;
482     (*KeywordMap)["u8vec4"] =                  U8VEC4;
483 
484     (*KeywordMap)["int16_t"] =                 INT16_T;
485     (*KeywordMap)["i16vec2"] =                 I16VEC2;
486     (*KeywordMap)["i16vec3"] =                 I16VEC3;
487     (*KeywordMap)["i16vec4"] =                 I16VEC4;
488     (*KeywordMap)["uint16_t"] =                UINT16_T;
489     (*KeywordMap)["u16vec2"] =                 U16VEC2;
490     (*KeywordMap)["u16vec3"] =                 U16VEC3;
491     (*KeywordMap)["u16vec4"] =                 U16VEC4;
492 
493     (*KeywordMap)["int32_t"] =                 INT32_T;
494     (*KeywordMap)["i32vec2"] =                 I32VEC2;
495     (*KeywordMap)["i32vec3"] =                 I32VEC3;
496     (*KeywordMap)["i32vec4"] =                 I32VEC4;
497     (*KeywordMap)["uint32_t"] =                UINT32_T;
498     (*KeywordMap)["u32vec2"] =                 U32VEC2;
499     (*KeywordMap)["u32vec3"] =                 U32VEC3;
500     (*KeywordMap)["u32vec4"] =                 U32VEC4;
501 
502     (*KeywordMap)["float16_t"] =               FLOAT16_T;
503     (*KeywordMap)["f16vec2"] =                 F16VEC2;
504     (*KeywordMap)["f16vec3"] =                 F16VEC3;
505     (*KeywordMap)["f16vec4"] =                 F16VEC4;
506     (*KeywordMap)["f16mat2"] =                 F16MAT2;
507     (*KeywordMap)["f16mat3"] =                 F16MAT3;
508     (*KeywordMap)["f16mat4"] =                 F16MAT4;
509     (*KeywordMap)["f16mat2x2"] =               F16MAT2X2;
510     (*KeywordMap)["f16mat2x3"] =               F16MAT2X3;
511     (*KeywordMap)["f16mat2x4"] =               F16MAT2X4;
512     (*KeywordMap)["f16mat3x2"] =               F16MAT3X2;
513     (*KeywordMap)["f16mat3x3"] =               F16MAT3X3;
514     (*KeywordMap)["f16mat3x4"] =               F16MAT3X4;
515     (*KeywordMap)["f16mat4x2"] =               F16MAT4X2;
516     (*KeywordMap)["f16mat4x3"] =               F16MAT4X3;
517     (*KeywordMap)["f16mat4x4"] =               F16MAT4X4;
518 
519     (*KeywordMap)["float32_t"] =               FLOAT32_T;
520     (*KeywordMap)["f32vec2"] =                 F32VEC2;
521     (*KeywordMap)["f32vec3"] =                 F32VEC3;
522     (*KeywordMap)["f32vec4"] =                 F32VEC4;
523     (*KeywordMap)["f32mat2"] =                 F32MAT2;
524     (*KeywordMap)["f32mat3"] =                 F32MAT3;
525     (*KeywordMap)["f32mat4"] =                 F32MAT4;
526     (*KeywordMap)["f32mat2x2"] =               F32MAT2X2;
527     (*KeywordMap)["f32mat2x3"] =               F32MAT2X3;
528     (*KeywordMap)["f32mat2x4"] =               F32MAT2X4;
529     (*KeywordMap)["f32mat3x2"] =               F32MAT3X2;
530     (*KeywordMap)["f32mat3x3"] =               F32MAT3X3;
531     (*KeywordMap)["f32mat3x4"] =               F32MAT3X4;
532     (*KeywordMap)["f32mat4x2"] =               F32MAT4X2;
533     (*KeywordMap)["f32mat4x3"] =               F32MAT4X3;
534     (*KeywordMap)["f32mat4x4"] =               F32MAT4X4;
535     (*KeywordMap)["float64_t"] =               FLOAT64_T;
536     (*KeywordMap)["f64vec2"] =                 F64VEC2;
537     (*KeywordMap)["f64vec3"] =                 F64VEC3;
538     (*KeywordMap)["f64vec4"] =                 F64VEC4;
539     (*KeywordMap)["f64mat2"] =                 F64MAT2;
540     (*KeywordMap)["f64mat3"] =                 F64MAT3;
541     (*KeywordMap)["f64mat4"] =                 F64MAT4;
542     (*KeywordMap)["f64mat2x2"] =               F64MAT2X2;
543     (*KeywordMap)["f64mat2x3"] =               F64MAT2X3;
544     (*KeywordMap)["f64mat2x4"] =               F64MAT2X4;
545     (*KeywordMap)["f64mat3x2"] =               F64MAT3X2;
546     (*KeywordMap)["f64mat3x3"] =               F64MAT3X3;
547     (*KeywordMap)["f64mat3x4"] =               F64MAT3X4;
548     (*KeywordMap)["f64mat4x2"] =               F64MAT4X2;
549     (*KeywordMap)["f64mat4x3"] =               F64MAT4X3;
550     (*KeywordMap)["f64mat4x4"] =               F64MAT4X4;
551 
552     (*KeywordMap)["sampler2D"] =               SAMPLER2D;
553     (*KeywordMap)["samplerCube"] =             SAMPLERCUBE;
554     (*KeywordMap)["samplerCubeArray"] =        SAMPLERCUBEARRAY;
555     (*KeywordMap)["samplerCubeArrayShadow"] =  SAMPLERCUBEARRAYSHADOW;
556     (*KeywordMap)["isamplerCubeArray"] =       ISAMPLERCUBEARRAY;
557     (*KeywordMap)["usamplerCubeArray"] =       USAMPLERCUBEARRAY;
558     (*KeywordMap)["sampler1DArrayShadow"] =    SAMPLER1DARRAYSHADOW;
559     (*KeywordMap)["isampler1DArray"] =         ISAMPLER1DARRAY;
560     (*KeywordMap)["usampler1D"] =              USAMPLER1D;
561     (*KeywordMap)["isampler1D"] =              ISAMPLER1D;
562     (*KeywordMap)["usampler1DArray"] =         USAMPLER1DARRAY;
563     (*KeywordMap)["samplerBuffer"] =           SAMPLERBUFFER;
564     (*KeywordMap)["samplerCubeShadow"] =       SAMPLERCUBESHADOW;
565     (*KeywordMap)["sampler2DArray"] =          SAMPLER2DARRAY;
566     (*KeywordMap)["sampler2DArrayShadow"] =    SAMPLER2DARRAYSHADOW;
567     (*KeywordMap)["isampler2D"] =              ISAMPLER2D;
568     (*KeywordMap)["isampler3D"] =              ISAMPLER3D;
569     (*KeywordMap)["isamplerCube"] =            ISAMPLERCUBE;
570     (*KeywordMap)["isampler2DArray"] =         ISAMPLER2DARRAY;
571     (*KeywordMap)["usampler2D"] =              USAMPLER2D;
572     (*KeywordMap)["usampler3D"] =              USAMPLER3D;
573     (*KeywordMap)["usamplerCube"] =            USAMPLERCUBE;
574     (*KeywordMap)["usampler2DArray"] =         USAMPLER2DARRAY;
575     (*KeywordMap)["isampler2DRect"] =          ISAMPLER2DRECT;
576     (*KeywordMap)["usampler2DRect"] =          USAMPLER2DRECT;
577     (*KeywordMap)["isamplerBuffer"] =          ISAMPLERBUFFER;
578     (*KeywordMap)["usamplerBuffer"] =          USAMPLERBUFFER;
579     (*KeywordMap)["sampler2DMS"] =             SAMPLER2DMS;
580     (*KeywordMap)["isampler2DMS"] =            ISAMPLER2DMS;
581     (*KeywordMap)["usampler2DMS"] =            USAMPLER2DMS;
582     (*KeywordMap)["sampler2DMSArray"] =        SAMPLER2DMSARRAY;
583     (*KeywordMap)["isampler2DMSArray"] =       ISAMPLER2DMSARRAY;
584     (*KeywordMap)["usampler2DMSArray"] =       USAMPLER2DMSARRAY;
585     (*KeywordMap)["sampler1D"] =               SAMPLER1D;
586     (*KeywordMap)["sampler1DShadow"] =         SAMPLER1DSHADOW;
587     (*KeywordMap)["sampler3D"] =               SAMPLER3D;
588     (*KeywordMap)["sampler2DShadow"] =         SAMPLER2DSHADOW;
589     (*KeywordMap)["sampler2DRect"] =           SAMPLER2DRECT;
590     (*KeywordMap)["sampler2DRectShadow"] =     SAMPLER2DRECTSHADOW;
591     (*KeywordMap)["sampler1DArray"] =          SAMPLER1DARRAY;
592 
593     (*KeywordMap)["samplerExternalOES"] =      SAMPLEREXTERNALOES; // GL_OES_EGL_image_external
594 
595     (*KeywordMap)["sampler"] =                 SAMPLER;
596     (*KeywordMap)["samplerShadow"] =           SAMPLERSHADOW;
597 
598     (*KeywordMap)["texture2D"] =               TEXTURE2D;
599     (*KeywordMap)["textureCube"] =             TEXTURECUBE;
600     (*KeywordMap)["textureCubeArray"] =        TEXTURECUBEARRAY;
601     (*KeywordMap)["itextureCubeArray"] =       ITEXTURECUBEARRAY;
602     (*KeywordMap)["utextureCubeArray"] =       UTEXTURECUBEARRAY;
603     (*KeywordMap)["itexture1DArray"] =         ITEXTURE1DARRAY;
604     (*KeywordMap)["utexture1D"] =              UTEXTURE1D;
605     (*KeywordMap)["itexture1D"] =              ITEXTURE1D;
606     (*KeywordMap)["utexture1DArray"] =         UTEXTURE1DARRAY;
607     (*KeywordMap)["textureBuffer"] =           TEXTUREBUFFER;
608     (*KeywordMap)["texture2DArray"] =          TEXTURE2DARRAY;
609     (*KeywordMap)["itexture2D"] =              ITEXTURE2D;
610     (*KeywordMap)["itexture3D"] =              ITEXTURE3D;
611     (*KeywordMap)["itextureCube"] =            ITEXTURECUBE;
612     (*KeywordMap)["itexture2DArray"] =         ITEXTURE2DARRAY;
613     (*KeywordMap)["utexture2D"] =              UTEXTURE2D;
614     (*KeywordMap)["utexture3D"] =              UTEXTURE3D;
615     (*KeywordMap)["utextureCube"] =            UTEXTURECUBE;
616     (*KeywordMap)["utexture2DArray"] =         UTEXTURE2DARRAY;
617     (*KeywordMap)["itexture2DRect"] =          ITEXTURE2DRECT;
618     (*KeywordMap)["utexture2DRect"] =          UTEXTURE2DRECT;
619     (*KeywordMap)["itextureBuffer"] =          ITEXTUREBUFFER;
620     (*KeywordMap)["utextureBuffer"] =          UTEXTUREBUFFER;
621     (*KeywordMap)["texture2DMS"] =             TEXTURE2DMS;
622     (*KeywordMap)["itexture2DMS"] =            ITEXTURE2DMS;
623     (*KeywordMap)["utexture2DMS"] =            UTEXTURE2DMS;
624     (*KeywordMap)["texture2DMSArray"] =        TEXTURE2DMSARRAY;
625     (*KeywordMap)["itexture2DMSArray"] =       ITEXTURE2DMSARRAY;
626     (*KeywordMap)["utexture2DMSArray"] =       UTEXTURE2DMSARRAY;
627     (*KeywordMap)["texture1D"] =               TEXTURE1D;
628     (*KeywordMap)["texture3D"] =               TEXTURE3D;
629     (*KeywordMap)["texture2DRect"] =           TEXTURE2DRECT;
630     (*KeywordMap)["texture1DArray"] =          TEXTURE1DARRAY;
631 
632     (*KeywordMap)["subpassInput"] =            SUBPASSINPUT;
633     (*KeywordMap)["subpassInputMS"] =          SUBPASSINPUTMS;
634     (*KeywordMap)["isubpassInput"] =           ISUBPASSINPUT;
635     (*KeywordMap)["isubpassInputMS"] =         ISUBPASSINPUTMS;
636     (*KeywordMap)["usubpassInput"] =           USUBPASSINPUT;
637     (*KeywordMap)["usubpassInputMS"] =         USUBPASSINPUTMS;
638 
639 #ifdef AMD_EXTENSIONS
640     (*KeywordMap)["f16sampler1D"] =                 F16SAMPLER1D;
641     (*KeywordMap)["f16sampler2D"] =                 F16SAMPLER2D;
642     (*KeywordMap)["f16sampler3D"] =                 F16SAMPLER3D;
643     (*KeywordMap)["f16sampler2DRect"] =             F16SAMPLER2DRECT;
644     (*KeywordMap)["f16samplerCube"] =               F16SAMPLERCUBE;
645     (*KeywordMap)["f16sampler1DArray"] =            F16SAMPLER1DARRAY;
646     (*KeywordMap)["f16sampler2DArray"] =            F16SAMPLER2DARRAY;
647     (*KeywordMap)["f16samplerCubeArray"] =          F16SAMPLERCUBEARRAY;
648     (*KeywordMap)["f16samplerBuffer"] =             F16SAMPLERBUFFER;
649     (*KeywordMap)["f16sampler2DMS"] =               F16SAMPLER2DMS;
650     (*KeywordMap)["f16sampler2DMSArray"] =          F16SAMPLER2DMSARRAY;
651     (*KeywordMap)["f16sampler1DShadow"] =           F16SAMPLER1DSHADOW;
652     (*KeywordMap)["f16sampler2DShadow"] =           F16SAMPLER2DSHADOW;
653     (*KeywordMap)["f16sampler2DRectShadow"] =       F16SAMPLER2DRECTSHADOW;
654     (*KeywordMap)["f16samplerCubeShadow"] =         F16SAMPLERCUBESHADOW;
655     (*KeywordMap)["f16sampler1DArrayShadow"] =      F16SAMPLER1DARRAYSHADOW;
656     (*KeywordMap)["f16sampler2DArrayShadow"] =      F16SAMPLER2DARRAYSHADOW;
657     (*KeywordMap)["f16samplerCubeArrayShadow"] =    F16SAMPLERCUBEARRAYSHADOW;
658 
659     (*KeywordMap)["f16image1D"] =                   F16IMAGE1D;
660     (*KeywordMap)["f16image2D"] =                   F16IMAGE2D;
661     (*KeywordMap)["f16image3D"] =                   F16IMAGE3D;
662     (*KeywordMap)["f16image2DRect"] =               F16IMAGE2DRECT;
663     (*KeywordMap)["f16imageCube"] =                 F16IMAGECUBE;
664     (*KeywordMap)["f16image1DArray"] =              F16IMAGE1DARRAY;
665     (*KeywordMap)["f16image2DArray"] =              F16IMAGE2DARRAY;
666     (*KeywordMap)["f16imageCubeArray"] =            F16IMAGECUBEARRAY;
667     (*KeywordMap)["f16imageBuffer"] =               F16IMAGEBUFFER;
668     (*KeywordMap)["f16image2DMS"] =                 F16IMAGE2DMS;
669     (*KeywordMap)["f16image2DMSArray"] =            F16IMAGE2DMSARRAY;
670 
671     (*KeywordMap)["f16texture1D"] =                 F16TEXTURE1D;
672     (*KeywordMap)["f16texture2D"] =                 F16TEXTURE2D;
673     (*KeywordMap)["f16texture3D"] =                 F16TEXTURE3D;
674     (*KeywordMap)["f16texture2DRect"] =             F16TEXTURE2DRECT;
675     (*KeywordMap)["f16textureCube"] =               F16TEXTURECUBE;
676     (*KeywordMap)["f16texture1DArray"] =            F16TEXTURE1DARRAY;
677     (*KeywordMap)["f16texture2DArray"] =            F16TEXTURE2DARRAY;
678     (*KeywordMap)["f16textureCubeArray"] =          F16TEXTURECUBEARRAY;
679     (*KeywordMap)["f16textureBuffer"] =             F16TEXTUREBUFFER;
680     (*KeywordMap)["f16texture2DMS"] =               F16TEXTURE2DMS;
681     (*KeywordMap)["f16texture2DMSArray"] =          F16TEXTURE2DMSARRAY;
682 
683     (*KeywordMap)["f16subpassInput"] =              F16SUBPASSINPUT;
684     (*KeywordMap)["f16subpassInputMS"] =            F16SUBPASSINPUTMS;
685 #endif
686 
687     (*KeywordMap)["noperspective"] =           NOPERSPECTIVE;
688     (*KeywordMap)["smooth"] =                  SMOOTH;
689     (*KeywordMap)["flat"] =                    FLAT;
690 #ifdef AMD_EXTENSIONS
691     (*KeywordMap)["__explicitInterpAMD"] =     EXPLICITINTERPAMD;
692 #endif
693     (*KeywordMap)["centroid"] =                CENTROID;
694 #ifdef NV_EXTENSIONS
695     (*KeywordMap)["pervertexNV"] =             PERVERTEXNV;
696 #endif
697     (*KeywordMap)["precise"] =                 PRECISE;
698     (*KeywordMap)["invariant"] =               INVARIANT;
699     (*KeywordMap)["packed"] =                  PACKED;
700     (*KeywordMap)["resource"] =                RESOURCE;
701     (*KeywordMap)["superp"] =                  SUPERP;
702 
703 #ifdef NV_EXTENSIONS
704     (*KeywordMap)["rayPayloadNV"] =            PAYLOADNV;
705     (*KeywordMap)["rayPayloadInNV"] =          PAYLOADINNV;
706     (*KeywordMap)["hitAttributeNV"] =          HITATTRNV;
707     (*KeywordMap)["callableDataNV"] =          CALLDATANV;
708     (*KeywordMap)["callableDataInNV"] =        CALLDATAINNV;
709     (*KeywordMap)["accelerationStructureNV"] = ACCSTRUCTNV;
710     (*KeywordMap)["perprimitiveNV"] =          PERPRIMITIVENV;
711     (*KeywordMap)["perviewNV"] =               PERVIEWNV;
712     (*KeywordMap)["taskNV"] =                  PERTASKNV;
713 #endif
714 
715     ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
716 
717     ReservedSet->insert("common");
718     ReservedSet->insert("partition");
719     ReservedSet->insert("active");
720     ReservedSet->insert("asm");
721     ReservedSet->insert("class");
722     ReservedSet->insert("union");
723     ReservedSet->insert("enum");
724     ReservedSet->insert("typedef");
725     ReservedSet->insert("template");
726     ReservedSet->insert("this");
727     ReservedSet->insert("goto");
728     ReservedSet->insert("inline");
729     ReservedSet->insert("noinline");
730     ReservedSet->insert("public");
731     ReservedSet->insert("static");
732     ReservedSet->insert("extern");
733     ReservedSet->insert("external");
734     ReservedSet->insert("interface");
735     ReservedSet->insert("long");
736     ReservedSet->insert("short");
737     ReservedSet->insert("half");
738     ReservedSet->insert("fixed");
739     ReservedSet->insert("unsigned");
740     ReservedSet->insert("input");
741     ReservedSet->insert("output");
742     ReservedSet->insert("hvec2");
743     ReservedSet->insert("hvec3");
744     ReservedSet->insert("hvec4");
745     ReservedSet->insert("fvec2");
746     ReservedSet->insert("fvec3");
747     ReservedSet->insert("fvec4");
748     ReservedSet->insert("sampler3DRect");
749     ReservedSet->insert("filter");
750     ReservedSet->insert("sizeof");
751     ReservedSet->insert("cast");
752     ReservedSet->insert("namespace");
753     ReservedSet->insert("using");
754 }
755 
deleteKeywordMap()756 void TScanContext::deleteKeywordMap()
757 {
758     delete KeywordMap;
759     KeywordMap = nullptr;
760     delete ReservedSet;
761     ReservedSet = nullptr;
762 }
763 
764 // Called by yylex to get the next token.
765 // Returning 0 implies end of input.
tokenize(TPpContext * pp,TParserToken & token)766 int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
767 {
768     do {
769         parserToken = &token;
770         TPpToken ppToken;
771         int token = pp->tokenize(ppToken);
772         if (token == EndOfInput)
773             return 0;
774 
775         tokenText = ppToken.name;
776         loc = ppToken.loc;
777         parserToken->sType.lex.loc = loc;
778         switch (token) {
779         case ';':  afterType = false; afterBuffer = false; return SEMICOLON;
780         case ',':  afterType = false;   return COMMA;
781         case ':':                       return COLON;
782         case '=':  afterType = false;   return EQUAL;
783         case '(':  afterType = false;   return LEFT_PAREN;
784         case ')':  afterType = false;   return RIGHT_PAREN;
785         case '.':  field = true;        return DOT;
786         case '!':                       return BANG;
787         case '-':                       return DASH;
788         case '~':                       return TILDE;
789         case '+':                       return PLUS;
790         case '*':                       return STAR;
791         case '/':                       return SLASH;
792         case '%':                       return PERCENT;
793         case '<':                       return LEFT_ANGLE;
794         case '>':                       return RIGHT_ANGLE;
795         case '|':                       return VERTICAL_BAR;
796         case '^':                       return CARET;
797         case '&':                       return AMPERSAND;
798         case '?':                       return QUESTION;
799         case '[':                       return LEFT_BRACKET;
800         case ']':                       return RIGHT_BRACKET;
801         case '{':  afterStruct = false; afterBuffer = false; return LEFT_BRACE;
802         case '}':                       return RIGHT_BRACE;
803         case '\\':
804             parseContext.error(loc, "illegal use of escape character", "\\", "");
805             break;
806 
807         case PPAtomAddAssign:          return ADD_ASSIGN;
808         case PPAtomSubAssign:          return SUB_ASSIGN;
809         case PPAtomMulAssign:          return MUL_ASSIGN;
810         case PPAtomDivAssign:          return DIV_ASSIGN;
811         case PPAtomModAssign:          return MOD_ASSIGN;
812 
813         case PpAtomRight:              return RIGHT_OP;
814         case PpAtomLeft:               return LEFT_OP;
815 
816         case PpAtomRightAssign:        return RIGHT_ASSIGN;
817         case PpAtomLeftAssign:         return LEFT_ASSIGN;
818         case PpAtomAndAssign:          return AND_ASSIGN;
819         case PpAtomOrAssign:           return OR_ASSIGN;
820         case PpAtomXorAssign:          return XOR_ASSIGN;
821 
822         case PpAtomAnd:                return AND_OP;
823         case PpAtomOr:                 return OR_OP;
824         case PpAtomXor:                return XOR_OP;
825 
826         case PpAtomEQ:                 return EQ_OP;
827         case PpAtomGE:                 return GE_OP;
828         case PpAtomNE:                 return NE_OP;
829         case PpAtomLE:                 return LE_OP;
830 
831         case PpAtomDecrement:          return DEC_OP;
832         case PpAtomIncrement:          return INC_OP;
833 
834         case PpAtomColonColon:
835             parseContext.error(loc, "not supported", "::", "");
836             break;
837 
838         case PpAtomConstInt:           parserToken->sType.lex.i    = ppToken.ival;       return INTCONSTANT;
839         case PpAtomConstUint:          parserToken->sType.lex.i    = ppToken.ival;       return UINTCONSTANT;
840         case PpAtomConstInt16:         parserToken->sType.lex.i    = ppToken.ival;       return INT16CONSTANT;
841         case PpAtomConstUint16:        parserToken->sType.lex.i    = ppToken.ival;       return UINT16CONSTANT;
842         case PpAtomConstInt64:         parserToken->sType.lex.i64  = ppToken.i64val;     return INT64CONSTANT;
843         case PpAtomConstUint64:        parserToken->sType.lex.i64  = ppToken.i64val;     return UINT64CONSTANT;
844         case PpAtomConstFloat:         parserToken->sType.lex.d    = ppToken.dval;       return FLOATCONSTANT;
845         case PpAtomConstDouble:        parserToken->sType.lex.d    = ppToken.dval;       return DOUBLECONSTANT;
846         case PpAtomConstFloat16:       parserToken->sType.lex.d    = ppToken.dval;       return FLOAT16CONSTANT;
847         case PpAtomIdentifier:
848         {
849             int token = tokenizeIdentifier();
850             field = false;
851             return token;
852         }
853 
854         case EndOfInput:               return 0;
855 
856         default:
857             char buf[2];
858             buf[0] = (char)token;
859             buf[1] = 0;
860             parseContext.error(loc, "unexpected token", buf, "");
861             break;
862         }
863     } while (true);
864 }
865 
tokenizeIdentifier()866 int TScanContext::tokenizeIdentifier()
867 {
868     if (ReservedSet->find(tokenText) != ReservedSet->end())
869         return reservedWord();
870 
871     auto it = KeywordMap->find(tokenText);
872     if (it == KeywordMap->end()) {
873         // Should have an identifier of some sort
874         return identifierOrType();
875     }
876     keyword = it->second;
877 
878     switch (keyword) {
879     case CONST:
880     case UNIFORM:
881     case IN:
882     case OUT:
883     case INOUT:
884     case BREAK:
885     case CONTINUE:
886     case DO:
887     case FOR:
888     case WHILE:
889     case IF:
890     case ELSE:
891     case DISCARD:
892     case RETURN:
893     case CASE:
894         return keyword;
895 
896     case STRUCT:
897         afterStruct = true;
898         return keyword;
899 
900     case NONUNIFORM:
901         if (parseContext.extensionTurnedOn(E_GL_EXT_nonuniform_qualifier))
902             return keyword;
903         else
904             return identifierOrType();
905 
906     case SWITCH:
907     case DEFAULT:
908         if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
909             (parseContext.profile != EEsProfile && parseContext.version < 130))
910             reservedWord();
911         return keyword;
912 
913     case VOID:
914     case BOOL:
915     case FLOAT:
916     case INT:
917     case BVEC2:
918     case BVEC3:
919     case BVEC4:
920     case VEC2:
921     case VEC3:
922     case VEC4:
923     case IVEC2:
924     case IVEC3:
925     case IVEC4:
926     case MAT2:
927     case MAT3:
928     case MAT4:
929     case SAMPLER2D:
930     case SAMPLERCUBE:
931         afterType = true;
932         return keyword;
933 
934     case BOOLCONSTANT:
935         if (strcmp("true", tokenText) == 0)
936             parserToken->sType.lex.b = true;
937         else
938             parserToken->sType.lex.b = false;
939         return keyword;
940 
941     case ATTRIBUTE:
942     case VARYING:
943         if (parseContext.profile == EEsProfile && parseContext.version >= 300)
944             reservedWord();
945         return keyword;
946 
947     case BUFFER:
948         afterBuffer = true;
949         if ((parseContext.profile == EEsProfile && parseContext.version < 310) ||
950             (parseContext.profile != EEsProfile && parseContext.version < 430))
951             return identifierOrType();
952         return keyword;
953 
954 #ifdef NV_EXTENSIONS
955     case PAYLOADNV:
956     case PAYLOADINNV:
957     case HITATTRNV:
958     case CALLDATANV:
959     case CALLDATAINNV:
960     case ACCSTRUCTNV:
961         if (parseContext.symbolTable.atBuiltInLevel() ||
962             (parseContext.profile != EEsProfile && parseContext.version >= 460
963                  && parseContext.extensionTurnedOn(E_GL_NV_ray_tracing)))
964             return keyword;
965         return identifierOrType();
966 #endif
967 
968     case ATOMIC_UINT:
969         if ((parseContext.profile == EEsProfile && parseContext.version >= 310) ||
970             parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters))
971             return keyword;
972         return es30ReservedFromGLSL(420);
973 
974     case COHERENT:
975     case DEVICECOHERENT:
976     case QUEUEFAMILYCOHERENT:
977     case WORKGROUPCOHERENT:
978     case SUBGROUPCOHERENT:
979     case NONPRIVATE:
980     case RESTRICT:
981     case READONLY:
982     case WRITEONLY:
983         if (parseContext.profile == EEsProfile && parseContext.version >= 310)
984             return keyword;
985         return es30ReservedFromGLSL(parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store) ? 130 : 420);
986 
987     case VOLATILE:
988         if (parseContext.profile == EEsProfile && parseContext.version >= 310)
989             return keyword;
990         if (! parseContext.symbolTable.atBuiltInLevel() && (parseContext.profile == EEsProfile ||
991             (parseContext.version < 420 && ! parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))))
992             reservedWord();
993         return keyword;
994 
995     case LAYOUT:
996     {
997         const int numLayoutExts = 2;
998         const char* layoutExts[numLayoutExts] = { E_GL_ARB_shading_language_420pack,
999                                                   E_GL_ARB_explicit_attrib_location };
1000         if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1001             (parseContext.profile != EEsProfile && parseContext.version < 140 &&
1002             ! parseContext.extensionsTurnedOn(numLayoutExts, layoutExts)))
1003             return identifierOrType();
1004         return keyword;
1005     }
1006     case SHARED:
1007         if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1008             (parseContext.profile != EEsProfile && parseContext.version < 140))
1009             return identifierOrType();
1010         return keyword;
1011 
1012     case PATCH:
1013         if (parseContext.symbolTable.atBuiltInLevel() ||
1014             (parseContext.profile == EEsProfile &&
1015              (parseContext.version >= 320 ||
1016               parseContext.extensionsTurnedOn(Num_AEP_tessellation_shader, AEP_tessellation_shader))) ||
1017             (parseContext.profile != EEsProfile && parseContext.extensionTurnedOn(E_GL_ARB_tessellation_shader)))
1018             return keyword;
1019 
1020         return es30ReservedFromGLSL(400);
1021 
1022     case SAMPLE:
1023         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1024             parseContext.extensionsTurnedOn(1, &E_GL_OES_shader_multisample_interpolation))
1025             return keyword;
1026         return es30ReservedFromGLSL(400);
1027 
1028     case SUBROUTINE:
1029         return es30ReservedFromGLSL(400);
1030 
1031     case HIGH_PRECISION:
1032     case MEDIUM_PRECISION:
1033     case LOW_PRECISION:
1034     case PRECISION:
1035         return precisionKeyword();
1036 
1037     case MAT2X2:
1038     case MAT2X3:
1039     case MAT2X4:
1040     case MAT3X2:
1041     case MAT3X3:
1042     case MAT3X4:
1043     case MAT4X2:
1044     case MAT4X3:
1045     case MAT4X4:
1046         return matNxM();
1047 
1048     case DMAT2:
1049     case DMAT3:
1050     case DMAT4:
1051     case DMAT2X2:
1052     case DMAT2X3:
1053     case DMAT2X4:
1054     case DMAT3X2:
1055     case DMAT3X3:
1056     case DMAT3X4:
1057     case DMAT4X2:
1058     case DMAT4X3:
1059     case DMAT4X4:
1060         return dMat();
1061 
1062     case IMAGE1D:
1063     case IIMAGE1D:
1064     case UIMAGE1D:
1065     case IMAGE1DARRAY:
1066     case IIMAGE1DARRAY:
1067     case UIMAGE1DARRAY:
1068     case IMAGE2DRECT:
1069     case IIMAGE2DRECT:
1070     case UIMAGE2DRECT:
1071         afterType = true;
1072         return firstGenerationImage(false);
1073 
1074     case IMAGEBUFFER:
1075     case IIMAGEBUFFER:
1076     case UIMAGEBUFFER:
1077         afterType = true;
1078         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1079             parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer))
1080             return keyword;
1081         return firstGenerationImage(false);
1082 
1083     case IMAGE2D:
1084     case IIMAGE2D:
1085     case UIMAGE2D:
1086     case IMAGE3D:
1087     case IIMAGE3D:
1088     case UIMAGE3D:
1089     case IMAGECUBE:
1090     case IIMAGECUBE:
1091     case UIMAGECUBE:
1092     case IMAGE2DARRAY:
1093     case IIMAGE2DARRAY:
1094     case UIMAGE2DARRAY:
1095         afterType = true;
1096         return firstGenerationImage(true);
1097 
1098     case IMAGECUBEARRAY:
1099     case IIMAGECUBEARRAY:
1100     case UIMAGECUBEARRAY:
1101         afterType = true;
1102         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1103             parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array))
1104             return keyword;
1105         return secondGenerationImage();
1106 
1107     case IMAGE2DMS:
1108     case IIMAGE2DMS:
1109     case UIMAGE2DMS:
1110     case IMAGE2DMSARRAY:
1111     case IIMAGE2DMSARRAY:
1112     case UIMAGE2DMSARRAY:
1113         afterType = true;
1114         return secondGenerationImage();
1115 
1116     case DOUBLE:
1117     case DVEC2:
1118     case DVEC3:
1119     case DVEC4:
1120         afterType = true;
1121         if (parseContext.profile == EEsProfile || parseContext.version < 400)
1122             reservedWord();
1123         return keyword;
1124 
1125     case INT64_T:
1126     case UINT64_T:
1127     case I64VEC2:
1128     case I64VEC3:
1129     case I64VEC4:
1130     case U64VEC2:
1131     case U64VEC3:
1132     case U64VEC4:
1133         afterType = true;
1134         if (parseContext.symbolTable.atBuiltInLevel() ||
1135             (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
1136              (parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64) ||
1137               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1138               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int64))))
1139             return keyword;
1140         return identifierOrType();
1141 
1142     case INT8_T:
1143     case UINT8_T:
1144     case I8VEC2:
1145     case I8VEC3:
1146     case I8VEC4:
1147     case U8VEC2:
1148     case U8VEC3:
1149     case U8VEC4:
1150         afterType = true;
1151         if (parseContext.symbolTable.atBuiltInLevel() ||
1152             ((parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1153               parseContext.extensionTurnedOn(E_GL_EXT_shader_8bit_storage) ||
1154               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8)) &&
1155               parseContext.profile != EEsProfile && parseContext.version >= 450))
1156             return keyword;
1157         return identifierOrType();
1158 
1159     case INT16_T:
1160     case UINT16_T:
1161     case I16VEC2:
1162     case I16VEC3:
1163     case I16VEC4:
1164     case U16VEC2:
1165     case U16VEC3:
1166     case U16VEC4:
1167         afterType = true;
1168         if (parseContext.symbolTable.atBuiltInLevel() ||
1169             (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
1170              (
1171 #ifdef AMD_EXTENSIONS
1172               parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) ||
1173 #endif
1174               parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
1175               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1176               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16))))
1177             return keyword;
1178         return identifierOrType();
1179     case INT32_T:
1180     case UINT32_T:
1181     case I32VEC2:
1182     case I32VEC3:
1183     case I32VEC4:
1184     case U32VEC2:
1185     case U32VEC3:
1186     case U32VEC4:
1187         afterType = true;
1188         if (parseContext.symbolTable.atBuiltInLevel() ||
1189            ((parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1190              parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int32)) &&
1191              parseContext.profile != EEsProfile && parseContext.version >= 450))
1192             return keyword;
1193         return identifierOrType();
1194     case FLOAT32_T:
1195     case F32VEC2:
1196     case F32VEC3:
1197     case F32VEC4:
1198     case F32MAT2:
1199     case F32MAT3:
1200     case F32MAT4:
1201     case F32MAT2X2:
1202     case F32MAT2X3:
1203     case F32MAT2X4:
1204     case F32MAT3X2:
1205     case F32MAT3X3:
1206     case F32MAT3X4:
1207     case F32MAT4X2:
1208     case F32MAT4X3:
1209     case F32MAT4X4:
1210         afterType = true;
1211         if (parseContext.symbolTable.atBuiltInLevel() ||
1212             ((parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1213               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float32)) &&
1214               parseContext.profile != EEsProfile && parseContext.version >= 450))
1215             return keyword;
1216         return identifierOrType();
1217 
1218     case FLOAT64_T:
1219     case F64VEC2:
1220     case F64VEC3:
1221     case F64VEC4:
1222     case F64MAT2:
1223     case F64MAT3:
1224     case F64MAT4:
1225     case F64MAT2X2:
1226     case F64MAT2X3:
1227     case F64MAT2X4:
1228     case F64MAT3X2:
1229     case F64MAT3X3:
1230     case F64MAT3X4:
1231     case F64MAT4X2:
1232     case F64MAT4X3:
1233     case F64MAT4X4:
1234         afterType = true;
1235         if (parseContext.symbolTable.atBuiltInLevel() ||
1236             ((parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1237               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float64)) &&
1238               parseContext.profile != EEsProfile && parseContext.version >= 450))
1239             return keyword;
1240         return identifierOrType();
1241 
1242     case FLOAT16_T:
1243     case F16VEC2:
1244     case F16VEC3:
1245     case F16VEC4:
1246         afterType = true;
1247         if (parseContext.symbolTable.atBuiltInLevel() ||
1248             (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
1249              (
1250 #ifdef AMD_EXTENSIONS
1251               parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) ||
1252 #endif
1253               parseContext.extensionTurnedOn(E_GL_EXT_shader_16bit_storage) ||
1254               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1255               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16))))
1256             return keyword;
1257 
1258         return identifierOrType();
1259 
1260     case F16MAT2:
1261     case F16MAT3:
1262     case F16MAT4:
1263     case F16MAT2X2:
1264     case F16MAT2X3:
1265     case F16MAT2X4:
1266     case F16MAT3X2:
1267     case F16MAT3X3:
1268     case F16MAT3X4:
1269     case F16MAT4X2:
1270     case F16MAT4X3:
1271     case F16MAT4X4:
1272         afterType = true;
1273         if (parseContext.symbolTable.atBuiltInLevel() ||
1274             (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
1275              (
1276 #ifdef AMD_EXTENSIONS
1277               parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float) ||
1278 #endif
1279               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
1280               parseContext.extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_float16))))
1281             return keyword;
1282 
1283         return identifierOrType();
1284 
1285     case SAMPLERCUBEARRAY:
1286     case SAMPLERCUBEARRAYSHADOW:
1287     case ISAMPLERCUBEARRAY:
1288     case USAMPLERCUBEARRAY:
1289         afterType = true;
1290         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1291             parseContext.extensionsTurnedOn(Num_AEP_texture_cube_map_array, AEP_texture_cube_map_array))
1292             return keyword;
1293         if (parseContext.profile == EEsProfile || (parseContext.version < 400 && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_cube_map_array)))
1294             reservedWord();
1295         return keyword;
1296 
1297     case ISAMPLER1D:
1298     case ISAMPLER1DARRAY:
1299     case SAMPLER1DARRAYSHADOW:
1300     case USAMPLER1D:
1301     case USAMPLER1DARRAY:
1302         afterType = true;
1303         return es30ReservedFromGLSL(130);
1304 
1305     case UINT:
1306     case UVEC2:
1307     case UVEC3:
1308     case UVEC4:
1309     case SAMPLERCUBESHADOW:
1310     case SAMPLER2DARRAY:
1311     case SAMPLER2DARRAYSHADOW:
1312     case ISAMPLER2D:
1313     case ISAMPLER3D:
1314     case ISAMPLERCUBE:
1315     case ISAMPLER2DARRAY:
1316     case USAMPLER2D:
1317     case USAMPLER3D:
1318     case USAMPLERCUBE:
1319     case USAMPLER2DARRAY:
1320         afterType = true;
1321         return nonreservedKeyword(300, 130);
1322 
1323     case ISAMPLER2DRECT:
1324     case USAMPLER2DRECT:
1325         afterType = true;
1326         return es30ReservedFromGLSL(140);
1327 
1328     case SAMPLERBUFFER:
1329         afterType = true;
1330         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1331             parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer))
1332             return keyword;
1333         return es30ReservedFromGLSL(130);
1334 
1335     case ISAMPLERBUFFER:
1336     case USAMPLERBUFFER:
1337         afterType = true;
1338         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1339             parseContext.extensionsTurnedOn(Num_AEP_texture_buffer, AEP_texture_buffer))
1340             return keyword;
1341         return es30ReservedFromGLSL(140);
1342 
1343     case SAMPLER2DMS:
1344     case ISAMPLER2DMS:
1345     case USAMPLER2DMS:
1346         afterType = true;
1347         if (parseContext.profile == EEsProfile && parseContext.version >= 310)
1348             return keyword;
1349         return es30ReservedFromGLSL(150);
1350 
1351     case SAMPLER2DMSARRAY:
1352     case ISAMPLER2DMSARRAY:
1353     case USAMPLER2DMSARRAY:
1354         afterType = true;
1355         if ((parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1356             parseContext.extensionsTurnedOn(1, &E_GL_OES_texture_storage_multisample_2d_array))
1357             return keyword;
1358         return es30ReservedFromGLSL(150);
1359 
1360     case SAMPLER1D:
1361     case SAMPLER1DSHADOW:
1362         afterType = true;
1363         if (parseContext.profile == EEsProfile)
1364             reservedWord();
1365         return keyword;
1366 
1367     case SAMPLER3D:
1368         afterType = true;
1369         if (parseContext.profile == EEsProfile && parseContext.version < 300) {
1370             if (!parseContext.extensionTurnedOn(E_GL_OES_texture_3D))
1371                 reservedWord();
1372         }
1373         return keyword;
1374 
1375     case SAMPLER2DSHADOW:
1376         afterType = true;
1377         if (parseContext.profile == EEsProfile && parseContext.version < 300) {
1378             if (!parseContext.extensionTurnedOn(E_GL_EXT_shadow_samplers))
1379                 reservedWord();
1380         }
1381         return keyword;
1382 
1383     case SAMPLER2DRECT:
1384     case SAMPLER2DRECTSHADOW:
1385         afterType = true;
1386         if (parseContext.profile == EEsProfile)
1387             reservedWord();
1388         else if (parseContext.version < 140 && ! parseContext.symbolTable.atBuiltInLevel() && ! parseContext.extensionTurnedOn(E_GL_ARB_texture_rectangle)) {
1389             if (parseContext.relaxedErrors())
1390                 parseContext.requireExtensions(loc, 1, &E_GL_ARB_texture_rectangle, "texture-rectangle sampler keyword");
1391             else
1392                 reservedWord();
1393         }
1394         return keyword;
1395 
1396     case SAMPLER1DARRAY:
1397         afterType = true;
1398         if (parseContext.profile == EEsProfile && parseContext.version == 300)
1399             reservedWord();
1400         else if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1401                  (parseContext.profile != EEsProfile && parseContext.version < 130))
1402             return identifierOrType();
1403         return keyword;
1404 
1405     case SAMPLEREXTERNALOES:
1406         afterType = true;
1407         if (parseContext.symbolTable.atBuiltInLevel() ||
1408             parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external) ||
1409             parseContext.extensionTurnedOn(E_GL_OES_EGL_image_external_essl3))
1410             return keyword;
1411         return identifierOrType();
1412 
1413     case TEXTURE2D:
1414     case TEXTURECUBE:
1415     case TEXTURECUBEARRAY:
1416     case ITEXTURECUBEARRAY:
1417     case UTEXTURECUBEARRAY:
1418     case ITEXTURE1DARRAY:
1419     case UTEXTURE1D:
1420     case ITEXTURE1D:
1421     case UTEXTURE1DARRAY:
1422     case TEXTUREBUFFER:
1423     case TEXTURE2DARRAY:
1424     case ITEXTURE2D:
1425     case ITEXTURE3D:
1426     case ITEXTURECUBE:
1427     case ITEXTURE2DARRAY:
1428     case UTEXTURE2D:
1429     case UTEXTURE3D:
1430     case UTEXTURECUBE:
1431     case UTEXTURE2DARRAY:
1432     case ITEXTURE2DRECT:
1433     case UTEXTURE2DRECT:
1434     case ITEXTUREBUFFER:
1435     case UTEXTUREBUFFER:
1436     case TEXTURE2DMS:
1437     case ITEXTURE2DMS:
1438     case UTEXTURE2DMS:
1439     case TEXTURE2DMSARRAY:
1440     case ITEXTURE2DMSARRAY:
1441     case UTEXTURE2DMSARRAY:
1442     case TEXTURE1D:
1443     case TEXTURE3D:
1444     case TEXTURE2DRECT:
1445     case TEXTURE1DARRAY:
1446     case SAMPLER:
1447     case SAMPLERSHADOW:
1448         if (parseContext.spvVersion.vulkan > 0)
1449             return keyword;
1450         else
1451             return identifierOrType();
1452 
1453     case SUBPASSINPUT:
1454     case SUBPASSINPUTMS:
1455     case ISUBPASSINPUT:
1456     case ISUBPASSINPUTMS:
1457     case USUBPASSINPUT:
1458     case USUBPASSINPUTMS:
1459         if (parseContext.spvVersion.vulkan > 0)
1460             return keyword;
1461         else
1462             return identifierOrType();
1463 
1464 #ifdef AMD_EXTENSIONS
1465     case F16SAMPLER1D:
1466     case F16SAMPLER2D:
1467     case F16SAMPLER3D:
1468     case F16SAMPLER2DRECT:
1469     case F16SAMPLERCUBE:
1470     case F16SAMPLER1DARRAY:
1471     case F16SAMPLER2DARRAY:
1472     case F16SAMPLERCUBEARRAY:
1473     case F16SAMPLERBUFFER:
1474     case F16SAMPLER2DMS:
1475     case F16SAMPLER2DMSARRAY:
1476     case F16SAMPLER1DSHADOW:
1477     case F16SAMPLER2DSHADOW:
1478     case F16SAMPLER1DARRAYSHADOW:
1479     case F16SAMPLER2DARRAYSHADOW:
1480     case F16SAMPLER2DRECTSHADOW:
1481     case F16SAMPLERCUBESHADOW:
1482     case F16SAMPLERCUBEARRAYSHADOW:
1483 
1484     case F16IMAGE1D:
1485     case F16IMAGE2D:
1486     case F16IMAGE3D:
1487     case F16IMAGE2DRECT:
1488     case F16IMAGECUBE:
1489     case F16IMAGE1DARRAY:
1490     case F16IMAGE2DARRAY:
1491     case F16IMAGECUBEARRAY:
1492     case F16IMAGEBUFFER:
1493     case F16IMAGE2DMS:
1494     case F16IMAGE2DMSARRAY:
1495 
1496     case F16TEXTURE1D:
1497     case F16TEXTURE2D:
1498     case F16TEXTURE3D:
1499     case F16TEXTURE2DRECT:
1500     case F16TEXTURECUBE:
1501     case F16TEXTURE1DARRAY:
1502     case F16TEXTURE2DARRAY:
1503     case F16TEXTURECUBEARRAY:
1504     case F16TEXTUREBUFFER:
1505     case F16TEXTURE2DMS:
1506     case F16TEXTURE2DMSARRAY:
1507 
1508     case F16SUBPASSINPUT:
1509     case F16SUBPASSINPUTMS:
1510         afterType = true;
1511         if (parseContext.symbolTable.atBuiltInLevel() ||
1512             (parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) &&
1513              parseContext.profile != EEsProfile && parseContext.version >= 450))
1514             return keyword;
1515         return identifierOrType();
1516 #endif
1517 
1518     case NOPERSPECTIVE:
1519 #ifdef NV_EXTENSIONS
1520         if (parseContext.profile == EEsProfile && parseContext.version >= 300 &&
1521             parseContext.extensionTurnedOn(E_GL_NV_shader_noperspective_interpolation))
1522             return keyword;
1523 #endif
1524         return es30ReservedFromGLSL(130);
1525 
1526     case SMOOTH:
1527         if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1528             (parseContext.profile != EEsProfile && parseContext.version < 130))
1529             return identifierOrType();
1530         return keyword;
1531 
1532 #ifdef AMD_EXTENSIONS
1533     case EXPLICITINTERPAMD:
1534         if (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
1535             parseContext.extensionTurnedOn(E_GL_AMD_shader_explicit_vertex_parameter))
1536             return keyword;
1537         return identifierOrType();
1538 #endif
1539 
1540 #ifdef NV_EXTENSIONS
1541     case PERVERTEXNV:
1542         if (((parseContext.profile != EEsProfile && parseContext.version >= 450) ||
1543             (parseContext.profile == EEsProfile && parseContext.version >= 320)) &&
1544             parseContext.extensionTurnedOn(E_GL_NV_fragment_shader_barycentric))
1545             return keyword;
1546         return identifierOrType();
1547 #endif
1548 
1549     case FLAT:
1550         if (parseContext.profile == EEsProfile && parseContext.version < 300)
1551             reservedWord();
1552         else if (parseContext.profile != EEsProfile && parseContext.version < 130)
1553             return identifierOrType();
1554         return keyword;
1555 
1556     case CENTROID:
1557         if (parseContext.version < 120)
1558             return identifierOrType();
1559         return keyword;
1560 
1561     case PRECISE:
1562         if ((parseContext.profile == EEsProfile &&
1563              (parseContext.version >= 320 || parseContext.extensionsTurnedOn(Num_AEP_gpu_shader5, AEP_gpu_shader5))) ||
1564             (parseContext.profile != EEsProfile && parseContext.version >= 400))
1565             return keyword;
1566         if (parseContext.profile == EEsProfile && parseContext.version == 310) {
1567             reservedWord();
1568             return keyword;
1569         }
1570         return identifierOrType();
1571 
1572     case INVARIANT:
1573         if (parseContext.profile != EEsProfile && parseContext.version < 120)
1574             return identifierOrType();
1575         return keyword;
1576 
1577     case PACKED:
1578         if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1579             (parseContext.profile != EEsProfile && parseContext.version < 330))
1580             return reservedWord();
1581         return identifierOrType();
1582 
1583     case RESOURCE:
1584     {
1585         bool reserved = (parseContext.profile == EEsProfile && parseContext.version >= 300) ||
1586                         (parseContext.profile != EEsProfile && parseContext.version >= 420);
1587         return identifierOrReserved(reserved);
1588     }
1589     case SUPERP:
1590     {
1591         bool reserved = parseContext.profile == EEsProfile || parseContext.version >= 130;
1592         return identifierOrReserved(reserved);
1593     }
1594 
1595 #ifdef NV_EXTENSIONS
1596     case PERPRIMITIVENV:
1597     case PERVIEWNV:
1598     case PERTASKNV:
1599         if ((parseContext.profile != EEsProfile && parseContext.version >= 450) ||
1600             (parseContext.profile == EEsProfile && parseContext.version >= 320) ||
1601             parseContext.extensionTurnedOn(E_GL_NV_mesh_shader))
1602             return keyword;
1603         return identifierOrType();
1604 #endif
1605 
1606     default:
1607         parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc);
1608         return 0;
1609     }
1610 }
1611 
identifierOrType()1612 int TScanContext::identifierOrType()
1613 {
1614     parserToken->sType.lex.string = NewPoolTString(tokenText);
1615     if (field)
1616         return IDENTIFIER;
1617 
1618     parserToken->sType.lex.symbol = parseContext.symbolTable.find(*parserToken->sType.lex.string);
1619     if ((afterType == false && afterStruct == false) && parserToken->sType.lex.symbol != nullptr) {
1620         if (const TVariable* variable = parserToken->sType.lex.symbol->getAsVariable()) {
1621             if (variable->isUserType() &&
1622                 // treat redeclaration of forward-declared buffer/uniform reference as an identifier
1623                 !(variable->getType().getBasicType() == EbtReference && afterBuffer)) {
1624                 afterType = true;
1625 
1626                 return TYPE_NAME;
1627             }
1628         }
1629     }
1630 
1631     return IDENTIFIER;
1632 }
1633 
1634 // Give an error for use of a reserved symbol.
1635 // However, allow built-in declarations to use reserved words, to allow
1636 // extension support before the extension is enabled.
reservedWord()1637 int TScanContext::reservedWord()
1638 {
1639     if (! parseContext.symbolTable.atBuiltInLevel())
1640         parseContext.error(loc, "Reserved word.", tokenText, "", "");
1641 
1642     return 0;
1643 }
1644 
identifierOrReserved(bool reserved)1645 int TScanContext::identifierOrReserved(bool reserved)
1646 {
1647     if (reserved) {
1648         reservedWord();
1649 
1650         return 0;
1651     }
1652 
1653     if (parseContext.forwardCompatible)
1654         parseContext.warn(loc, "using future reserved keyword", tokenText, "");
1655 
1656     return identifierOrType();
1657 }
1658 
1659 // For keywords that suddenly showed up on non-ES (not previously reserved)
1660 // but then got reserved by ES 3.0.
es30ReservedFromGLSL(int version)1661 int TScanContext::es30ReservedFromGLSL(int version)
1662 {
1663     if (parseContext.symbolTable.atBuiltInLevel())
1664         return keyword;
1665 
1666     if ((parseContext.profile == EEsProfile && parseContext.version < 300) ||
1667         (parseContext.profile != EEsProfile && parseContext.version < version)) {
1668             if (parseContext.forwardCompatible)
1669                 parseContext.warn(loc, "future reserved word in ES 300 and keyword in GLSL", tokenText, "");
1670 
1671             return identifierOrType();
1672     } else if (parseContext.profile == EEsProfile && parseContext.version >= 300)
1673         reservedWord();
1674 
1675     return keyword;
1676 }
1677 
1678 // For a keyword that was never reserved, until it suddenly
1679 // showed up, both in an es version and a non-ES version.
nonreservedKeyword(int esVersion,int nonEsVersion)1680 int TScanContext::nonreservedKeyword(int esVersion, int nonEsVersion)
1681 {
1682     if ((parseContext.profile == EEsProfile && parseContext.version < esVersion) ||
1683         (parseContext.profile != EEsProfile && parseContext.version < nonEsVersion)) {
1684         if (parseContext.forwardCompatible)
1685             parseContext.warn(loc, "using future keyword", tokenText, "");
1686 
1687         return identifierOrType();
1688     }
1689 
1690     return keyword;
1691 }
1692 
precisionKeyword()1693 int TScanContext::precisionKeyword()
1694 {
1695     if (parseContext.profile == EEsProfile || parseContext.version >= 130)
1696         return keyword;
1697 
1698     if (parseContext.forwardCompatible)
1699         parseContext.warn(loc, "using ES precision qualifier keyword", tokenText, "");
1700 
1701     return identifierOrType();
1702 }
1703 
matNxM()1704 int TScanContext::matNxM()
1705 {
1706     afterType = true;
1707 
1708     if (parseContext.version > 110)
1709         return keyword;
1710 
1711     if (parseContext.forwardCompatible)
1712         parseContext.warn(loc, "using future non-square matrix type keyword", tokenText, "");
1713 
1714     return identifierOrType();
1715 }
1716 
dMat()1717 int TScanContext::dMat()
1718 {
1719     afterType = true;
1720 
1721     if (parseContext.profile == EEsProfile && parseContext.version >= 300) {
1722         reservedWord();
1723 
1724         return keyword;
1725     }
1726 
1727     if (parseContext.profile != EEsProfile && parseContext.version >= 400)
1728         return keyword;
1729 
1730     if (parseContext.forwardCompatible)
1731         parseContext.warn(loc, "using future type keyword", tokenText, "");
1732 
1733     return identifierOrType();
1734 }
1735 
firstGenerationImage(bool inEs310)1736 int TScanContext::firstGenerationImage(bool inEs310)
1737 {
1738     if (parseContext.symbolTable.atBuiltInLevel() ||
1739         (parseContext.profile != EEsProfile && (parseContext.version >= 420 ||
1740          parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))) ||
1741         (inEs310 && parseContext.profile == EEsProfile && parseContext.version >= 310))
1742         return keyword;
1743 
1744     if ((parseContext.profile == EEsProfile && parseContext.version >= 300) ||
1745         (parseContext.profile != EEsProfile && parseContext.version >= 130)) {
1746         reservedWord();
1747 
1748         return keyword;
1749     }
1750 
1751     if (parseContext.forwardCompatible)
1752         parseContext.warn(loc, "using future type keyword", tokenText, "");
1753 
1754     return identifierOrType();
1755 }
1756 
secondGenerationImage()1757 int TScanContext::secondGenerationImage()
1758 {
1759     if (parseContext.profile == EEsProfile && parseContext.version >= 310) {
1760         reservedWord();
1761         return keyword;
1762     }
1763 
1764     if (parseContext.symbolTable.atBuiltInLevel() ||
1765         (parseContext.profile != EEsProfile &&
1766          (parseContext.version >= 420 || parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))))
1767         return keyword;
1768 
1769     if (parseContext.forwardCompatible)
1770         parseContext.warn(loc, "using future type keyword", tokenText, "");
1771 
1772     return identifierOrType();
1773 }
1774 
1775 } // end namespace glslang
1776