src/compiler/glsl/glsl_lexer.ll

   1 %{
   2 /*
   3  * Copyright © 2008, 2009 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 #include <ctype.h>
  25 #include <limits.h>
  26 #include "util/strtod.h"
  27 #include "ast.h"
  28 #include "glsl_parser_extras.h"
  29 #include "glsl_parser.h"
  30
  31 static int classify_identifier(struct _mesa_glsl_parse_state *, const char *);
  32
  33 #ifdef _MSC_VER
  34 #define YY_NO_UNISTD_H
  35 #endif
  36
  37 #define YY_USER_ACTION                                          \
  38    do {                                                         \
  39       yylloc->first_column = yycolumn + 1;                      \
  40       yylloc->first_line = yylloc->last_line = yylineno + 1;    \
  41       yycolumn += yyleng;                                       \
  42       yylloc->last_column = yycolumn + 1;                       \
  43    } while(0);
  44
  45 #define YY_USER_INIT yylineno = 0; yycolumn = 0; yylloc->source = 0;
  46
  47 /* A macro for handling reserved words and keywords across language versions.
  48  *
  49  * Certain words start out as identifiers, become reserved words in
  50  * later language revisions, and finally become language keywords.
  51  * This may happen at different times in desktop GLSL and GLSL ES.
  52  *
  53  * For example, consider the following lexer rule:
  54  * samplerBuffer       KEYWORD(130, 0, 140, 0, SAMPLERBUFFER)
  55  *
  56  * This means that "samplerBuffer" will be treated as:
  57  * - a keyword (SAMPLERBUFFER token)         ...in GLSL >= 1.40
  58  * - a reserved word - error                 ...in GLSL >= 1.30
  59  * - an identifier                           ...in GLSL <  1.30 or GLSL ES
  60  */
  61 #define KEYWORD(reserved_glsl, reserved_glsl_es,                        \
  62                 allowed_glsl, allowed_glsl_es, token)                   \
  63    KEYWORD_WITH_ALT(reserved_glsl, reserved_glsl_es,                    \
  64                     allowed_glsl, allowed_glsl_es, false, token)
  65
  66 /**
  67  * Like the KEYWORD macro, but the word is also treated as a keyword
  68  * if the given boolean expression is true.
  69  */
  70 #define KEYWORD_WITH_ALT(reserved_glsl, reserved_glsl_es,               \
  71                          allowed_glsl, allowed_glsl_es,                 \
  72                          alt_expr, token)                               \
  73    do {                                                                 \
  74       if (yyextra->is_version(allowed_glsl, allowed_glsl_es)            \
  75           || (alt_expr)) {                                              \
  76          return token;                                                  \
  77       } else if (yyextra->is_version(reserved_glsl,                     \
  78                                      reserved_glsl_es)) {               \
  79          _mesa_glsl_error(yylloc, yyextra,                              \
  80                           "illegal use of reserved word `%s'", yytext); \
  81          return ERROR_TOK;                                              \
  82       } else {                                                          \
  83          void *mem_ctx = yyextra;                                       \
  84          yylval->identifier = ralloc_strdup(mem_ctx, yytext);           \
  85          return classify_identifier(yyextra, yytext);                   \
  86       }                                                                 \
  87    } while (0)
  88
  89 /**
  90  * A macro for handling keywords that have been present in GLSL since
  91  * its origin, but were changed into reserved words in GLSL 3.00 ES.
  92  */
  93 #define DEPRECATED_ES_KEYWORD(token)                                    \
  94    do {                                                                 \
  95       if (yyextra->is_version(0, 300)) {                                \
  96          _mesa_glsl_error(yylloc, yyextra,                              \
  97                           "illegal use of reserved word `%s'", yytext); \
  98          return ERROR_TOK;                                              \
  99       } else {                                                          \
 100          return token;                                                  \
 101       }                                                                 \
 102    } while (0)
 103
 104 static int
 105 literal_integer(char *text, int len, struct _mesa_glsl_parse_state *state,
 106                 YYSTYPE *lval, YYLTYPE *lloc, int base)
 107 {
 108    bool is_uint = (text[len - 1] == 'u' ||
 109                    text[len - 1] == 'U');
 110    const char *digits = text;
 111
 112    /* Skip "0x" */
 113    if (base == 16)
 114       digits += 2;
 115
 116    unsigned long long value = strtoull(digits, NULL, base);
 117
 118    lval->n = (int)value;
 119
 120    if (value > UINT_MAX) {
 121       /* Note that signed 0xffffffff is valid, not out of range! */
 122       if (state->is_version(130, 300)) {
 123          _mesa_glsl_error(lloc, state,
 124                           "literal value `%s' out of range", text);
 125       } else {
 126          _mesa_glsl_warning(lloc, state,
 127                             "literal value `%s' out of range", text);
 128       }
 129    } else if (base == 10 && !is_uint && (unsigned)value > (unsigned)INT_MAX + 1) {
 130       /* Tries to catch unintentionally providing a negative value.
 131        * Note that -2147483648 is parsed as -(2147483648), so we don't
 132        * want to warn for INT_MAX.
 133        */
 134       _mesa_glsl_warning(lloc, state,
 135                          "signed literal value `%s' is interpreted as %d",
 136                          text, lval->n);
 137    }
 138    return is_uint ? UINTCONSTANT : INTCONSTANT;
 139 }
 140
 141 #define LITERAL_INTEGER(base) \
 142    literal_integer(yytext, yyleng, yyextra, yylval, yylloc, base)
 143
 144 %}
 145
 146 %option bison-bridge bison-locations reentrant noyywrap
 147 %option nounput noyy_top_state
 148 %option never-interactive
 149 %option prefix="_mesa_glsl_lexer_"
 150 %option extra-type="struct _mesa_glsl_parse_state *"
 151 %option warn nodefault
 152
 153         /* Note: When adding any start conditions to this list, you must also
 154          * update the "Internal compiler error" catch-all rule near the end of
 155          * this file. */
 156 %x PP PRAGMA
 157
 158 DEC_INT         [1-9][0-9]*
 159 HEX_INT         0[xX][0-9a-fA-F]+
 160 OCT_INT         0[0-7]*
 161 INT             ({DEC_INT}|{HEX_INT}|{OCT_INT})
 162 SPC             [ \t]*
 163 SPCP            [ \t]+
 164 HASH            ^{SPC}#{SPC}
 165 %%
 166
 167 [ \r\t]+                ;
 168
 169     /* Preprocessor tokens. */
 170 ^[ \t]*#[ \t]*$                 ;
 171 ^[ \t]*#[ \t]*version           { BEGIN PP; return VERSION_TOK; }
 172 ^[ \t]*#[ \t]*extension         { BEGIN PP; return EXTENSION; }
 173 {HASH}line{SPCP}{INT}{SPCP}{INT}{SPC}$ {
 174                                    /* Eat characters until the first digit is
 175                                     * encountered
 176                                     */
 177                                    char *ptr = yytext;
 178                                    while (!isdigit(*ptr))
 179                                       ptr++;
 180
 181                                    /* Subtract one from the line number because
 182                                     * yylineno is zero-based instead of
 183                                     * one-based.
 184                                     */
 185                                    yylineno = strtol(ptr, &ptr, 0) - 1;
 186
 187                                    /* From GLSL 3.30 and GLSL ES on, after processing the
 188                                     * line directive (including its new-line), the implementation
 189                                     * will behave as if it is compiling at the line number passed
 190                                     * as argument. It was line number + 1 in older specifications.
 191                                     */
 192                                    if (yyextra->is_version(330, 100))
 193                                       yylineno--;
 194
 195                                    yylloc->source = strtol(ptr, NULL, 0);
 196                                 }
 197 {HASH}line{SPCP}{INT}{SPC}$     {
 198                                    /* Eat characters until the first digit is
 199                                     * encountered
 200                                     */
 201                                    char *ptr = yytext;
 202                                    while (!isdigit(*ptr))
 203                                       ptr++;
 204
 205                                    /* Subtract one from the line number because
 206                                     * yylineno is zero-based instead of
 207                                     * one-based.
 208                                     */
 209                                    yylineno = strtol(ptr, &ptr, 0) - 1;
 210
 211                                    /* From GLSL 3.30 and GLSL ES on, after processing the
 212                                     * line directive (including its new-line), the implementation
 213                                     * will behave as if it is compiling at the line number passed
 214                                     * as argument. It was line number + 1 in older specifications.
 215                                     */
 216                                    if (yyextra->is_version(330, 100))
 217                                       yylineno--;
 218                                 }
 219 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) {
 220                                   BEGIN PP;
 221                                   return PRAGMA_DEBUG_ON;
 222                                 }
 223 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) {
 224                                   BEGIN PP;
 225                                   return PRAGMA_DEBUG_OFF;
 226                                 }
 227 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) {
 228                                   BEGIN PP;
 229                                   return PRAGMA_OPTIMIZE_ON;
 230                                 }
 231 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) {
 232                                   BEGIN PP;
 233                                   return PRAGMA_OPTIMIZE_OFF;
 234                                 }
 235 ^{SPC}#{SPC}pragma{SPCP}STDGL{SPCP}invariant{SPC}\({SPC}all{SPC}\) {
 236                                   BEGIN PP;
 237                                   return PRAGMA_INVARIANT_ALL;
 238                                 }
 239 ^{SPC}#{SPC}pragma{SPCP}        { BEGIN PRAGMA; }
 240
 241 <PRAGMA>\n                      { BEGIN 0; yylineno++; yycolumn = 0; }
 242 <PRAGMA>.                       { }
 243
 244 <PP>\/\/[^\n]*                  { }
 245 <PP>[ \t\r]*                    { }
 246 <PP>:                           return COLON;
 247 <PP>[_a-zA-Z][_a-zA-Z0-9]*      {
 248                                    void *mem_ctx = yyextra;
 249                                    yylval->identifier = ralloc_strdup(mem_ctx, yytext);
 250                                    return IDENTIFIER;
 251                                 }
 252 <PP>[1-9][0-9]*                 {
 253                                     yylval->n = strtol(yytext, NULL, 10);
 254                                     return INTCONSTANT;
 255                                 }
 256 <PP>\n                          { BEGIN 0; yylineno++; yycolumn = 0; return EOL; }
 257 <PP>.                           { return yytext[0]; }
 258
 259 \n              { yylineno++; yycolumn = 0; }
 260
 261 attribute       DEPRECATED_ES_KEYWORD(ATTRIBUTE);
 262 const           return CONST_TOK;
 263 bool            return BOOL_TOK;
 264 float           return FLOAT_TOK;
 265 int             return INT_TOK;
 266 uint            KEYWORD(130, 300, 130, 300, UINT_TOK);
 267
 268 break           return BREAK;
 269 continue        return CONTINUE;
 270 do              return DO;
 271 while           return WHILE;
 272 else            return ELSE;
 273 for             return FOR;
 274 if              return IF;
 275 discard         return DISCARD;
 276 return          return RETURN;
 277
 278 bvec2           return BVEC2;
 279 bvec3           return BVEC3;
 280 bvec4           return BVEC4;
 281 ivec2           return IVEC2;
 282 ivec3           return IVEC3;
 283 ivec4           return IVEC4;
 284 uvec2           KEYWORD(130, 300, 130, 300, UVEC2);
 285 uvec3           KEYWORD(130, 300, 130, 300, UVEC3);
 286 uvec4           KEYWORD(130, 300, 130, 300, UVEC4);
 287 vec2            return VEC2;
 288 vec3            return VEC3;
 289 vec4            return VEC4;
 290 mat2            return MAT2X2;
 291 mat3            return MAT3X3;
 292 mat4            return MAT4X4;
 293 mat2x2          KEYWORD(120, 300, 120, 300, MAT2X2);
 294 mat2x3          KEYWORD(120, 300, 120, 300, MAT2X3);
 295 mat2x4          KEYWORD(120, 300, 120, 300, MAT2X4);
 296 mat3x2          KEYWORD(120, 300, 120, 300, MAT3X2);
 297 mat3x3          KEYWORD(120, 300, 120, 300, MAT3X3);
 298 mat3x4          KEYWORD(120, 300, 120, 300, MAT3X4);
 299 mat4x2          KEYWORD(120, 300, 120, 300, MAT4X2);
 300 mat4x3          KEYWORD(120, 300, 120, 300, MAT4X3);
 301 mat4x4          KEYWORD(120, 300, 120, 300, MAT4X4);
 302
 303 in              return IN_TOK;
 304 out             return OUT_TOK;
 305 inout           return INOUT_TOK;
 306 uniform         return UNIFORM;
 307 buffer          return BUFFER;
 308 varying         DEPRECATED_ES_KEYWORD(VARYING);
 309 centroid        KEYWORD(120, 300, 120, 300, CENTROID);
 310 invariant       KEYWORD(120, 100, 120, 100, INVARIANT);
 311 flat            KEYWORD(130, 100, 130, 300, FLAT);
 312 smooth          KEYWORD(130, 300, 130, 300, SMOOTH);
 313 noperspective   KEYWORD(130, 300, 130, 0, NOPERSPECTIVE);
 314 patch           KEYWORD_WITH_ALT(0, 300, 400, 0, yyextra->ARB_tessellation_shader_enable, PATCH);
 315
 316 sampler1D       DEPRECATED_ES_KEYWORD(SAMPLER1D);
 317 sampler2D       return SAMPLER2D;
 318 sampler3D       return SAMPLER3D;
 319 samplerCube     return SAMPLERCUBE;
 320 sampler1DArray  KEYWORD(130, 300, 130, 0, SAMPLER1DARRAY);
 321 sampler2DArray  KEYWORD(130, 300, 130, 300, SAMPLER2DARRAY);
 322 sampler1DShadow DEPRECATED_ES_KEYWORD(SAMPLER1DSHADOW);
 323 sampler2DShadow return SAMPLER2DSHADOW;
 324 samplerCubeShadow       KEYWORD(130, 300, 130, 300, SAMPLERCUBESHADOW);
 325 sampler1DArrayShadow    KEYWORD(130, 300, 130, 0, SAMPLER1DARRAYSHADOW);
 326 sampler2DArrayShadow    KEYWORD(130, 300, 130, 300, SAMPLER2DARRAYSHADOW);
 327 isampler1D              KEYWORD(130, 300, 130, 0, ISAMPLER1D);
 328 isampler2D              KEYWORD(130, 300, 130, 300, ISAMPLER2D);
 329 isampler3D              KEYWORD(130, 300, 130, 300, ISAMPLER3D);
 330 isamplerCube            KEYWORD(130, 300, 130, 300, ISAMPLERCUBE);
 331 isampler1DArray         KEYWORD(130, 300, 130, 0, ISAMPLER1DARRAY);
 332 isampler2DArray         KEYWORD(130, 300, 130, 300, ISAMPLER2DARRAY);
 333 usampler1D              KEYWORD(130, 300, 130, 0, USAMPLER1D);
 334 usampler2D              KEYWORD(130, 300, 130, 300, USAMPLER2D);
 335 usampler3D              KEYWORD(130, 300, 130, 300, USAMPLER3D);
 336 usamplerCube            KEYWORD(130, 300, 130, 300, USAMPLERCUBE);
 337 usampler1DArray         KEYWORD(130, 300, 130, 0, USAMPLER1DARRAY);
 338 usampler2DArray         KEYWORD(130, 300, 130, 300, USAMPLER2DARRAY);
 339
 340    /* additional keywords in ARB_texture_multisample, included in GLSL 1.50 */
 341    /* these are reserved but not defined in GLSL 3.00 */
 342    /* [iu]sampler2DMS are defined in GLSL ES 3.10 */
 343 sampler2DMS        KEYWORD_WITH_ALT(150, 300, 150, 310, yyextra->ARB_texture_multisample_enable, SAMPLER2DMS);
 344 isampler2DMS       KEYWORD_WITH_ALT(150, 300, 150, 310, yyextra->ARB_texture_multisample_enable, ISAMPLER2DMS);
 345 usampler2DMS       KEYWORD_WITH_ALT(150, 300, 150, 310, yyextra->ARB_texture_multisample_enable, USAMPLER2DMS);
 346 sampler2DMSArray   KEYWORD_WITH_ALT(150, 300, 150, 320, yyextra->ARB_texture_multisample_enable || yyextra->OES_texture_storage_multisample_2d_array_enable, SAMPLER2DMSARRAY);
 347 isampler2DMSArray  KEYWORD_WITH_ALT(150, 300, 150, 320, yyextra->ARB_texture_multisample_enable || yyextra->OES_texture_storage_multisample_2d_array_enable, ISAMPLER2DMSARRAY);
 348 usampler2DMSArray  KEYWORD_WITH_ALT(150, 300, 150, 320, yyextra->ARB_texture_multisample_enable || yyextra->OES_texture_storage_multisample_2d_array_enable, USAMPLER2DMSARRAY);
 349
 350    /* keywords available with ARB_texture_cube_map_array_enable extension on desktop GLSL */
 351 samplerCubeArray   KEYWORD_WITH_ALT(400, 0, 400, 0, yyextra->ARB_texture_cube_map_array_enable, SAMPLERCUBEARRAY);
 352 isamplerCubeArray KEYWORD_WITH_ALT(400, 0, 400, 0, yyextra->ARB_texture_cube_map_array_enable, ISAMPLERCUBEARRAY);
 353 usamplerCubeArray KEYWORD_WITH_ALT(400, 0, 400, 0, yyextra->ARB_texture_cube_map_array_enable, USAMPLERCUBEARRAY);
 354 samplerCubeArrayShadow   KEYWORD_WITH_ALT(400, 0, 400, 0, yyextra->ARB_texture_cube_map_array_enable, SAMPLERCUBEARRAYSHADOW);
 355
 356 samplerExternalOES              {
 357                           if (yyextra->OES_EGL_image_external_enable)
 358                              return SAMPLEREXTERNALOES;
 359                           else
 360                              return IDENTIFIER;
 361                 }
 362
 363    /* keywords available with ARB_gpu_shader5 */
 364 precise         KEYWORD_WITH_ALT(400, 310, 400, 320, yyextra->ARB_gpu_shader5_enable || yyextra->EXT_gpu_shader5_enable || yyextra->OES_gpu_shader5_enable, PRECISE);
 365
 366    /* keywords available with ARB_shader_image_load_store */
 367 image1D         KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGE1D);
 368 image2D         KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IMAGE2D);
 369 image3D         KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IMAGE3D);
 370 image2DRect     KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGE2DRECT);
 371 imageCube       KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IMAGECUBE);
 372 imageBuffer     KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGEBUFFER);
 373 image1DArray    KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGE1DARRAY);
 374 image2DArray    KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IMAGE2DARRAY);
 375 imageCubeArray  KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGECUBEARRAY);
 376 image2DMS       KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGE2DMS);
 377 image2DMSArray  KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IMAGE2DMSARRAY);
 378 iimage1D        KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGE1D);
 379 iimage2D        KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IIMAGE2D);
 380 iimage3D        KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IIMAGE3D);
 381 iimage2DRect    KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGE2DRECT);
 382 iimageCube      KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IIMAGECUBE);
 383 iimageBuffer    KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGEBUFFER);
 384 iimage1DArray   KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGE1DARRAY);
 385 iimage2DArray   KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, IIMAGE2DARRAY);
 386 iimageCubeArray KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGECUBEARRAY);
 387 iimage2DMS      KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGE2DMS);
 388 iimage2DMSArray KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, IIMAGE2DMSARRAY);
 389 uimage1D        KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGE1D);
 390 uimage2D        KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, UIMAGE2D);
 391 uimage3D        KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, UIMAGE3D);
 392 uimage2DRect    KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGE2DRECT);
 393 uimageCube      KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, UIMAGECUBE);
 394 uimageBuffer    KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGEBUFFER);
 395 uimage1DArray   KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGE1DARRAY);
 396 uimage2DArray   KEYWORD_WITH_ALT(130, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable, UIMAGE2DARRAY);
 397 uimageCubeArray KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGECUBEARRAY);
 398 uimage2DMS      KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGE2DMS);
 399 uimage2DMSArray KEYWORD_WITH_ALT(130, 300, 420, 0, yyextra->ARB_shader_image_load_store_enable, UIMAGE2DMSARRAY);
 400 image1DShadow           KEYWORD(130, 300, 0, 0, IMAGE1DSHADOW);
 401 image2DShadow           KEYWORD(130, 300, 0, 0, IMAGE2DSHADOW);
 402 image1DArrayShadow      KEYWORD(130, 300, 0, 0, IMAGE1DARRAYSHADOW);
 403 image2DArrayShadow      KEYWORD(130, 300, 0, 0, IMAGE2DARRAYSHADOW);
 404
 405 coherent       KEYWORD_WITH_ALT(420, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable || yyextra->ARB_shader_storage_buffer_object_enable, COHERENT);
 406 volatile       KEYWORD_WITH_ALT(110, 100, 420, 310, yyextra->ARB_shader_image_load_store_enable || yyextra->ARB_shader_storage_buffer_object_enable, VOLATILE);
 407 restrict       KEYWORD_WITH_ALT(420, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable || yyextra->ARB_shader_storage_buffer_object_enable, RESTRICT);
 408 readonly       KEYWORD_WITH_ALT(420, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable || yyextra->ARB_shader_storage_buffer_object_enable, READONLY);
 409 writeonly      KEYWORD_WITH_ALT(420, 300, 420, 310, yyextra->ARB_shader_image_load_store_enable || yyextra->ARB_shader_storage_buffer_object_enable, WRITEONLY);
 410
 411 atomic_uint     KEYWORD_WITH_ALT(420, 300, 420, 310, yyextra->ARB_shader_atomic_counters_enable, ATOMIC_UINT);
 412
 413 shared          KEYWORD_WITH_ALT(430, 310, 430, 310, yyextra->ARB_compute_shader_enable, SHARED);
 414
 415 struct          return STRUCT;
 416 void            return VOID_TOK;
 417
 418 layout          {
 419                   if ((yyextra->is_version(140, 300))
 420                       || yyextra->AMD_conservative_depth_enable
 421                       || yyextra->ARB_conservative_depth_enable
 422                       || yyextra->ARB_explicit_attrib_location_enable
 423                       || yyextra->ARB_explicit_uniform_location_enable
 424                       || yyextra->has_separate_shader_objects()
 425                       || yyextra->ARB_uniform_buffer_object_enable
 426                       || yyextra->ARB_fragment_coord_conventions_enable
 427                       || yyextra->ARB_shading_language_420pack_enable
 428                       || yyextra->ARB_compute_shader_enable
 429                       || yyextra->ARB_tessellation_shader_enable) {
 430                       return LAYOUT_TOK;
 431                    } else {
 432                       void *mem_ctx = yyextra;
 433                       yylval->identifier = ralloc_strdup(mem_ctx, yytext);
 434                       return classify_identifier(yyextra, yytext);
 435                    }
 436                 }
 437
 438 \+\+            return INC_OP;
 439 --              return DEC_OP;
 440 \<=             return LE_OP;
 441 >=              return GE_OP;
 442 ==              return EQ_OP;
 443 !=              return NE_OP;
 444 &&              return AND_OP;
 445 \|\|            return OR_OP;
 446 "^^"            return XOR_OP;
 447 "<<"            return LEFT_OP;
 448 ">>"            return RIGHT_OP;
 449
 450 \*=             return MUL_ASSIGN;
 451 \/=             return DIV_ASSIGN;
 452 \+=             return ADD_ASSIGN;
 453 \%=             return MOD_ASSIGN;
 454 \<\<=           return LEFT_ASSIGN;
 455 >>=             return RIGHT_ASSIGN;
 456 &=              return AND_ASSIGN;
 457 "^="            return XOR_ASSIGN;
 458 \|=             return OR_ASSIGN;
 459 -=              return SUB_ASSIGN;
 460
 461 [1-9][0-9]*[uU]?        {
 462                             return LITERAL_INTEGER(10);
 463                         }
 464 0[xX][0-9a-fA-F]+[uU]?  {
 465                             return LITERAL_INTEGER(16);
 466                         }
 467 0[0-7]*[uU]?            {
 468                             return LITERAL_INTEGER(8);
 469                         }
 470
 471 [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?   |
 472 \.[0-9]+([eE][+-]?[0-9]+)?[fF]?         |
 473 [0-9]+\.([eE][+-]?[0-9]+)?[fF]?         |
 474 [0-9]+[eE][+-]?[0-9]+[fF]?              {
 475                             yylval->real = _mesa_strtof(yytext, NULL);
 476                             return FLOATCONSTANT;
 477                         }
 478
 479 [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?(lf|LF) |
 480 \.[0-9]+([eE][+-]?[0-9]+)?(lf|LF)       |
 481 [0-9]+\.([eE][+-]?[0-9]+)?(lf|LF)       |
 482 [0-9]+[eE][+-]?[0-9]+(lf|LF)            {
 483                             if (!yyextra->is_version(400, 0) &&
 484                                 !yyextra->ARB_gpu_shader_fp64_enable)
 485                                 return ERROR_TOK;
 486                             yylval->dreal = _mesa_strtod(yytext, NULL);
 487                             return DOUBLECONSTANT;
 488                         }
 489
 490 true                    {
 491                             yylval->n = 1;
 492                             return BOOLCONSTANT;
 493                         }
 494 false                   {
 495                             yylval->n = 0;
 496                             return BOOLCONSTANT;
 497                         }
 498
 499
 500     /* Reserved words in GLSL 1.10. */
 501 asm             KEYWORD(110, 100, 0, 0, ASM);
 502 class           KEYWORD(110, 100, 0, 0, CLASS);
 503 union           KEYWORD(110, 100, 0, 0, UNION);
 504 enum            KEYWORD(110, 100, 0, 0, ENUM);
 505 typedef         KEYWORD(110, 100, 0, 0, TYPEDEF);
 506 template        KEYWORD(110, 100, 0, 0, TEMPLATE);
 507 this            KEYWORD(110, 100, 0, 0, THIS);
 508 packed          KEYWORD_WITH_ALT(110, 100, 140, 300, yyextra->ARB_uniform_buffer_object_enable, PACKED_TOK);
 509 goto            KEYWORD(110, 100, 0, 0, GOTO);
 510 switch          KEYWORD(110, 100, 130, 300, SWITCH);
 511 default         KEYWORD(110, 100, 130, 300, DEFAULT);
 512 inline          KEYWORD(110, 100, 0, 0, INLINE_TOK);
 513 noinline        KEYWORD(110, 100, 0, 0, NOINLINE);
 514 public          KEYWORD(110, 100, 0, 0, PUBLIC_TOK);
 515 static          KEYWORD(110, 100, 0, 0, STATIC);
 516 extern          KEYWORD(110, 100, 0, 0, EXTERN);
 517 external        KEYWORD(110, 100, 0, 0, EXTERNAL);
 518 interface       KEYWORD(110, 100, 0, 0, INTERFACE);
 519 long            KEYWORD(110, 100, 0, 0, LONG_TOK);
 520 short           KEYWORD(110, 100, 0, 0, SHORT_TOK);
 521 double          KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DOUBLE_TOK);
 522 half            KEYWORD(110, 100, 0, 0, HALF);
 523 fixed           KEYWORD(110, 100, 0, 0, FIXED_TOK);
 524 unsigned        KEYWORD(110, 100, 0, 0, UNSIGNED);
 525 input           KEYWORD(110, 100, 0, 0, INPUT_TOK);
 526 output          KEYWORD(110, 100, 0, 0, OUTPUT);
 527 hvec2           KEYWORD(110, 100, 0, 0, HVEC2);
 528 hvec3           KEYWORD(110, 100, 0, 0, HVEC3);
 529 hvec4           KEYWORD(110, 100, 0, 0, HVEC4);
 530 dvec2           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DVEC2);
 531 dvec3           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DVEC3);
 532 dvec4           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DVEC4);
 533 dmat2           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT2X2);
 534 dmat3           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT3X3);
 535 dmat4           KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT4X4);
 536 dmat2x2         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT2X2);
 537 dmat2x3         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT2X3);
 538 dmat2x4         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT2X4);
 539 dmat3x2         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT3X2);
 540 dmat3x3         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT3X3);
 541 dmat3x4         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT3X4);
 542 dmat4x2         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT4X2);
 543 dmat4x3         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT4X3);
 544 dmat4x4         KEYWORD_WITH_ALT(110, 100, 400, 0, yyextra->ARB_gpu_shader_fp64_enable, DMAT4X4);
 545 fvec2           KEYWORD(110, 100, 0, 0, FVEC2);
 546 fvec3           KEYWORD(110, 100, 0, 0, FVEC3);
 547 fvec4           KEYWORD(110, 100, 0, 0, FVEC4);
 548 sampler2DRect           DEPRECATED_ES_KEYWORD(SAMPLER2DRECT);
 549 sampler3DRect           KEYWORD(110, 100, 0, 0, SAMPLER3DRECT);
 550 sampler2DRectShadow     DEPRECATED_ES_KEYWORD(SAMPLER2DRECTSHADOW);
 551 sizeof          KEYWORD(110, 100, 0, 0, SIZEOF);
 552 cast            KEYWORD(110, 100, 0, 0, CAST);
 553 namespace       KEYWORD(110, 100, 0, 0, NAMESPACE);
 554 using           KEYWORD(110, 100, 0, 0, USING);
 555
 556     /* Additional reserved words in GLSL 1.20. */
 557 lowp            KEYWORD(120, 100, 130, 100, LOWP);
 558 mediump         KEYWORD(120, 100, 130, 100, MEDIUMP);
 559 highp           KEYWORD(120, 100, 130, 100, HIGHP);
 560 precision       KEYWORD(120, 100, 130, 100, PRECISION);
 561
 562     /* Additional reserved words in GLSL 1.30. */
 563 case            KEYWORD(130, 300, 130, 300, CASE);
 564 common          KEYWORD(130, 300, 0, 0, COMMON);
 565 partition       KEYWORD(130, 300, 0, 0, PARTITION);
 566 active          KEYWORD(130, 300, 0, 0, ACTIVE);
 567 superp          KEYWORD(130, 100, 0, 0, SUPERP);
 568 samplerBuffer   KEYWORD(130, 300, 140, 0, SAMPLERBUFFER);
 569 filter          KEYWORD(130, 300, 0, 0, FILTER);
 570 row_major       KEYWORD_WITH_ALT(130, 0, 140, 0, yyextra->ARB_uniform_buffer_object_enable && !yyextra->es_shader, ROW_MAJOR);
 571
 572     /* Additional reserved words in GLSL 1.40 */
 573 isampler2DRect  KEYWORD(140, 300, 140, 0, ISAMPLER2DRECT);
 574 usampler2DRect  KEYWORD(140, 300, 140, 0, USAMPLER2DRECT);
 575 isamplerBuffer  KEYWORD(140, 300, 140, 0, ISAMPLERBUFFER);
 576 usamplerBuffer  KEYWORD(140, 300, 140, 0, USAMPLERBUFFER);
 577
 578     /* Additional reserved words in GLSL ES 3.00 */
 579 resource        KEYWORD(0, 300, 0, 0, RESOURCE);
 580 sample          KEYWORD_WITH_ALT(400, 300, 400, 0, yyextra->ARB_gpu_shader5_enable, SAMPLE);
 581 subroutine      KEYWORD_WITH_ALT(400, 300, 400, 0, yyextra->ARB_shader_subroutine_enable, SUBROUTINE);
 582
 583
 584 [_a-zA-Z][_a-zA-Z0-9]*  {
 585                             struct _mesa_glsl_parse_state *state = yyextra;
 586                             void *ctx = state;
 587                             if (state->es_shader && strlen(yytext) > 1024) {
 588                                _mesa_glsl_error(yylloc, state,
 589                                                 "Identifier `%s' exceeds 1024 characters",
 590                                                 yytext);
 591                             } else {
 592                               yylval->identifier = ralloc_strdup(ctx, yytext);
 593                             }
 594                             return classify_identifier(state, yytext);
 595                         }
 596
 597 \.                      { struct _mesa_glsl_parse_state *state = yyextra;
 598                           state->is_field = true;
 599                           return DOT_TOK; }
 600
 601 .                       { return yytext[0]; }
 602
 603 %%
 604
 605 int
 606 classify_identifier(struct _mesa_glsl_parse_state *state, const char *name)
 607 {
 608    if (state->is_field) {
 609       state->is_field = false;
 610       return FIELD_SELECTION;
 611    }
 612    if (state->symbols->get_variable(name) || state->symbols->get_function(name))
 613       return IDENTIFIER;
 614    else if (state->symbols->get_type(name))
 615       return TYPE_IDENTIFIER;
 616    else
 617       return NEW_IDENTIFIER;
 618 }
 619
 620 void
 621 _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string)
 622 {
 623    yylex_init_extra(state, & state->scanner);
 624    yy_scan_string(string, state->scanner);
 625 }
 626
 627 void
 628 _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state)
 629 {
 630    yylex_destroy(state->scanner);
 631 }