glslang/MachineIndependent/Scan.cpp

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