src/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 "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->source = 0;                                       \
  40       yylloc->first_column = yycolumn + 1;                      \
  41       yylloc->first_line = yylineno + 1;                        \
  42       yycolumn += yyleng;                                       \
  43    } while(0);
  44
  45 #define YY_USER_INIT yylineno = 0; yycolumn = 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          yylval->identifier = strdup(yytext);                           \
  84          return classify_identifier(yyextra, yytext);                   \
  85       }                                                                 \
  86    } while (0)
  87
  88 /**
  89  * A macro for handling keywords that have been present in GLSL since
  90  * its origin, but were changed into reserved words in GLSL 3.00 ES.
  91  */
  92 #define DEPRECATED_ES_KEYWORD(token)                                    \
  93    do {                                                                 \
  94       if (yyextra->is_version(0, 300)) {                                \
  95          _mesa_glsl_error(yylloc, yyextra,                              \
  96                           "Illegal use of reserved word `%s'", yytext); \
  97          return ERROR_TOK;                                              \
  98       } else {                                                          \
  99          return token;                                                  \
 100       }                                                                 \
 101    } while (0)
 102
 103 static int
 104 literal_integer(char *text, int len, struct _mesa_glsl_parse_state *state,
 105                 YYSTYPE *lval, YYLTYPE *lloc, int base)
 106 {
 107    bool is_uint = (text[len - 1] == 'u' ||
 108                    text[len - 1] == 'U');
 109    const char *digits = text;
 110
 111    /* Skip "0x" */
 112    if (base == 16)
 113       digits += 2;
 114
 115 #ifdef _MSC_VER
 116    unsigned __int64 value = _strtoui64(digits, NULL, base);
 117 #else
 118    unsigned long long value = strtoull(digits, NULL, base);
 119 #endif
 120
 121    lval->n = (int)value;
 122
 123    if (value > UINT_MAX) {
 124       /* Note that signed 0xffffffff is valid, not out of range! */
 125       if (state->is_version(130, 300)) {
 126          _mesa_glsl_error(lloc, state,
 127                           "Literal value `%s' out of range", text);
 128       } else {
 129          _mesa_glsl_warning(lloc, state,
 130                             "Literal value `%s' out of range", text);
 131       }
 132    } else if (base == 10 && !is_uint && (unsigned)value > (unsigned)INT_MAX + 1) {
 133       /* Tries to catch unintentionally providing a negative value.
 134        * Note that -2147483648 is parsed as -(2147483648), so we don't
 135        * want to warn for INT_MAX.
 136        */
 137       _mesa_glsl_warning(lloc, state,
 138                          "Signed literal value `%s' is interpreted as %d",
 139                          text, lval->n);
 140    }
 141    return is_uint ? UINTCONSTANT : INTCONSTANT;
 142 }
 143
 144 #define LITERAL_INTEGER(base) \
 145    literal_integer(yytext, yyleng, yyextra, yylval, yylloc, base)
 146
 147 %}
 148
 149 %option bison-bridge bison-locations reentrant noyywrap
 150 %option nounput noyy_top_state
 151 %option never-interactive
 152 %option prefix="_mesa_glsl_"
 153 %option extra-type="struct _mesa_glsl_parse_state *"
 154
 155 %x PP PRAGMA
 156
 157 DEC_INT         [1-9][0-9]*
 158 HEX_INT         0[xX][0-9a-fA-F]+
 159 OCT_INT         0[0-7]*
 160 INT             ({DEC_INT}|{HEX_INT}|{OCT_INT})
 161 SPC             [ \t]*
 162 SPCP            [ \t]+
 163 HASH            ^{SPC}#{SPC}
 164 %%
 165
 166 [ \r\t]+                ;
 167
 168     /* Preprocessor tokens. */
 169 ^[ \t]*#[ \t]*$                 ;
 170 ^[ \t]*#[ \t]*version           { BEGIN PP; return VERSION_TOK; }
 171 ^[ \t]*#[ \t]*extension         { BEGIN PP; return EXTENSION; }
 172 {HASH}line{SPCP}{INT}{SPCP}{INT}{SPC}$ {
 173                                    /* Eat characters until the first digit is
 174                                     * encountered
 175                                     */
 176                                    char *ptr = yytext;
 177                                    while (!isdigit(*ptr))
 178                                       ptr++;
 179
 180                                    /* Subtract one from the line number because
 181                                     * yylineno is zero-based instead of
 182                                     * one-based.
 183                                     */
 184                                    yylineno = strtol(ptr, &ptr, 0) - 1;
 185                                    yylloc->source = strtol(ptr, NULL, 0);
 186                                 }
 187 {HASH}line{SPCP}{INT}{SPC}$     {
 188                                    /* Eat characters until the first digit is
 189                                     * encountered
 190                                     */
 191                                    char *ptr = yytext;
 192                                    while (!isdigit(*ptr))
 193                                       ptr++;
 194
 195                                    /* Subtract one from the line number because
 196                                     * yylineno is zero-based instead of
 197                                     * one-based.
 198                                     */
 199                                    yylineno = strtol(ptr, &ptr, 0) - 1;
 200                                 }
 201 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) {
 202                                   BEGIN PP;
 203                                   return PRAGMA_DEBUG_ON;
 204                                 }
 205 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) {
 206                                   BEGIN PP;
 207                                   return PRAGMA_DEBUG_OFF;
 208                                 }
 209 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) {
 210                                   BEGIN PP;
 211                                   return PRAGMA_OPTIMIZE_ON;
 212                                 }
 213 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) {
 214                                   BEGIN PP;
 215                                   return PRAGMA_OPTIMIZE_OFF;
 216                                 }
 217 ^{SPC}#{SPC}pragma{SPCP}STDGL{SPCP}invariant{SPC}\({SPC}all{SPC}\) {
 218                                   BEGIN PP;
 219                                   return PRAGMA_INVARIANT_ALL;
 220                                 }
 221 ^{SPC}#{SPC}pragma{SPCP}        { BEGIN PRAGMA; }
 222
 223 <PRAGMA>\n                      { BEGIN 0; yylineno++; yycolumn = 0; }
 224 <PRAGMA>.                       { }
 225
 226 <PP>\/\/[^\n]*                  { }
 227 <PP>[ \t\r]*                    { }
 228 <PP>:                           return COLON;
 229 <PP>[_a-zA-Z][_a-zA-Z0-9]*      {
 230                                    yylval->identifier = strdup(yytext);
 231                                    return IDENTIFIER;
 232                                 }
 233 <PP>[1-9][0-9]*                 {
 234                                     yylval->n = strtol(yytext, NULL, 10);
 235                                     return INTCONSTANT;
 236                                 }
 237 <PP>\n                          { BEGIN 0; yylineno++; yycolumn = 0; return EOL; }
 238
 239 \n              { yylineno++; yycolumn = 0; }
 240
 241 attribute       DEPRECATED_ES_KEYWORD(ATTRIBUTE);
 242 const           return CONST_TOK;
 243 bool            return BOOL_TOK;
 244 float           return FLOAT_TOK;
 245 int             return INT_TOK;
 246 uint            KEYWORD(130, 300, 130, 300, UINT_TOK);
 247
 248 break           return BREAK;
 249 continue        return CONTINUE;
 250 do              return DO;
 251 while           return WHILE;
 252 else            return ELSE;
 253 for             return FOR;
 254 if              return IF;
 255 discard         return DISCARD;
 256 return          return RETURN;
 257
 258 bvec2           return BVEC2;
 259 bvec3           return BVEC3;
 260 bvec4           return BVEC4;
 261 ivec2           return IVEC2;
 262 ivec3           return IVEC3;
 263 ivec4           return IVEC4;
 264 uvec2           KEYWORD(130, 300, 130, 300, UVEC2);
 265 uvec3           KEYWORD(130, 300, 130, 300, UVEC3);
 266 uvec4           KEYWORD(130, 300, 130, 300, UVEC4);
 267 vec2            return VEC2;
 268 vec3            return VEC3;
 269 vec4            return VEC4;
 270 mat2            return MAT2X2;
 271 mat3            return MAT3X3;
 272 mat4            return MAT4X4;
 273 mat2x2          KEYWORD(120, 300, 120, 300, MAT2X2);
 274 mat2x3          KEYWORD(120, 300, 120, 300, MAT2X3);
 275 mat2x4          KEYWORD(120, 300, 120, 300, MAT2X4);
 276 mat3x2          KEYWORD(120, 300, 120, 300, MAT3X2);
 277 mat3x3          KEYWORD(120, 300, 120, 300, MAT3X3);
 278 mat3x4          KEYWORD(120, 300, 120, 300, MAT3X4);
 279 mat4x2          KEYWORD(120, 300, 120, 300, MAT4X2);
 280 mat4x3          KEYWORD(120, 300, 120, 300, MAT4X3);
 281 mat4x4          KEYWORD(120, 300, 120, 300, MAT4X4);
 282
 283 in              return IN_TOK;
 284 out             return OUT_TOK;
 285 inout           return INOUT_TOK;
 286 uniform         return UNIFORM;
 287 varying         DEPRECATED_ES_KEYWORD(VARYING);
 288 centroid        KEYWORD(120, 300, 120, 300, CENTROID);
 289 invariant       KEYWORD(120, 100, 120, 100, INVARIANT);
 290 flat            KEYWORD(130, 100, 130, 300, FLAT);
 291 smooth          KEYWORD(130, 300, 130, 300, SMOOTH);
 292 noperspective   KEYWORD(130, 300, 130, 0, NOPERSPECTIVE);
 293
 294 sampler1D       DEPRECATED_ES_KEYWORD(SAMPLER1D);
 295 sampler2D       return SAMPLER2D;
 296 sampler3D       return SAMPLER3D;
 297 samplerCube     return SAMPLERCUBE;
 298 sampler1DArray  KEYWORD(130, 300, 130, 0, SAMPLER1DARRAY);
 299 sampler2DArray  KEYWORD(130, 300, 130, 300, SAMPLER2DARRAY);
 300 sampler1DShadow DEPRECATED_ES_KEYWORD(SAMPLER1DSHADOW);
 301 sampler2DShadow return SAMPLER2DSHADOW;
 302 samplerCubeShadow       KEYWORD(130, 300, 130, 300, SAMPLERCUBESHADOW);
 303 sampler1DArrayShadow    KEYWORD(130, 300, 130, 0, SAMPLER1DARRAYSHADOW);
 304 sampler2DArrayShadow    KEYWORD(130, 300, 130, 300, SAMPLER2DARRAYSHADOW);
 305 isampler1D              KEYWORD(130, 300, 130, 0, ISAMPLER1D);
 306 isampler2D              KEYWORD(130, 300, 130, 300, ISAMPLER2D);
 307 isampler3D              KEYWORD(130, 300, 130, 300, ISAMPLER3D);
 308 isamplerCube            KEYWORD(130, 300, 130, 300, ISAMPLERCUBE);
 309 isampler1DArray         KEYWORD(130, 300, 130, 0, ISAMPLER1DARRAY);
 310 isampler2DArray         KEYWORD(130, 300, 130, 300, ISAMPLER2DARRAY);
 311 usampler1D              KEYWORD(130, 300, 130, 0, USAMPLER1D);
 312 usampler2D              KEYWORD(130, 300, 130, 300, USAMPLER2D);
 313 usampler3D              KEYWORD(130, 300, 130, 300, USAMPLER3D);
 314 usamplerCube            KEYWORD(130, 300, 130, 300, USAMPLERCUBE);
 315 usampler1DArray         KEYWORD(130, 300, 130, 0, USAMPLER1DARRAY);
 316 usampler2DArray         KEYWORD(130, 300, 130, 300, USAMPLER2DARRAY);
 317
 318    /* additional keywords in ARB_texture_multisample, included in GLSL 1.50 */
 319    /* these are reserved but not defined in GLSL 3.00 */
 320 sampler2DMS        KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, SAMPLER2DMS);
 321 isampler2DMS       KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, ISAMPLER2DMS);
 322 usampler2DMS       KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, USAMPLER2DMS);
 323 sampler2DMSArray   KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, SAMPLER2DMSARRAY);
 324 isampler2DMSArray  KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, ISAMPLER2DMSARRAY);
 325 usampler2DMSArray  KEYWORD_WITH_ALT(150, 300, 150, 0, yyextra->ARB_texture_multisample_enable, USAMPLER2DMSARRAY);
 326
 327 samplerCubeArray        {
 328                           if (yyextra->ARB_texture_cube_map_array_enable)
 329                              return SAMPLERCUBEARRAY;
 330                           else
 331                              return IDENTIFIER;
 332                 }
 333 isamplerCubeArray       {
 334                           if (yyextra->ARB_texture_cube_map_array_enable)
 335                              return ISAMPLERCUBEARRAY;
 336                           else
 337                              return IDENTIFIER;
 338                 }
 339 usamplerCubeArray       {
 340                           if (yyextra->ARB_texture_cube_map_array_enable)
 341                              return USAMPLERCUBEARRAY;
 342                           else
 343                              return IDENTIFIER;
 344                 }
 345 samplerCubeArrayShadow  {
 346                           if (yyextra->ARB_texture_cube_map_array_enable)
 347                              return SAMPLERCUBEARRAYSHADOW;
 348                           else
 349                              return IDENTIFIER;
 350                 }
 351
 352 samplerExternalOES              {
 353                           if (yyextra->OES_EGL_image_external_enable)
 354                              return SAMPLEREXTERNALOES;
 355                           else
 356                              return IDENTIFIER;
 357                 }
 358
 359
 360 struct          return STRUCT;
 361 void            return VOID_TOK;
 362
 363 layout          {
 364                   if ((yyextra->is_version(140, 300))
 365                       || yyextra->AMD_conservative_depth_enable
 366                       || yyextra->ARB_conservative_depth_enable
 367                       || yyextra->ARB_explicit_attrib_location_enable
 368                       || yyextra->ARB_uniform_buffer_object_enable
 369                       || yyextra->ARB_fragment_coord_conventions_enable) {
 370                       return LAYOUT_TOK;
 371                    } else {
 372                       yylval->identifier = strdup(yytext);
 373                       return IDENTIFIER;
 374                    }
 375                 }
 376
 377 \+\+            return INC_OP;
 378 --              return DEC_OP;
 379 \<=             return LE_OP;
 380 >=              return GE_OP;
 381 ==              return EQ_OP;
 382 !=              return NE_OP;
 383 &&              return AND_OP;
 384 \|\|            return OR_OP;
 385 "^^"            return XOR_OP;
 386 "<<"            return LEFT_OP;
 387 ">>"            return RIGHT_OP;
 388
 389 \*=             return MUL_ASSIGN;
 390 \/=             return DIV_ASSIGN;
 391 \+=             return ADD_ASSIGN;
 392 \%=             return MOD_ASSIGN;
 393 \<\<=           return LEFT_ASSIGN;
 394 >>=             return RIGHT_ASSIGN;
 395 &=              return AND_ASSIGN;
 396 "^="            return XOR_ASSIGN;
 397 \|=             return OR_ASSIGN;
 398 -=              return SUB_ASSIGN;
 399
 400 [1-9][0-9]*[uU]?        {
 401                             return LITERAL_INTEGER(10);
 402                         }
 403 0[xX][0-9a-fA-F]+[uU]?  {
 404                             return LITERAL_INTEGER(16);
 405                         }
 406 0[0-7]*[uU]?            {
 407                             return LITERAL_INTEGER(8);
 408                         }
 409
 410 [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?   {
 411                             yylval->real = glsl_strtof(yytext, NULL);
 412                             return FLOATCONSTANT;
 413                         }
 414 \.[0-9]+([eE][+-]?[0-9]+)?[fF]?         {
 415                             yylval->real = glsl_strtof(yytext, NULL);
 416                             return FLOATCONSTANT;
 417                         }
 418 [0-9]+\.([eE][+-]?[0-9]+)?[fF]?         {
 419                             yylval->real = glsl_strtof(yytext, NULL);
 420                             return FLOATCONSTANT;
 421                         }
 422 [0-9]+[eE][+-]?[0-9]+[fF]?              {
 423                             yylval->real = glsl_strtof(yytext, NULL);
 424                             return FLOATCONSTANT;
 425                         }
 426 [0-9]+[fF]              {
 427                             yylval->real = glsl_strtof(yytext, NULL);
 428                             return FLOATCONSTANT;
 429                         }
 430
 431 true                    {
 432                             yylval->n = 1;
 433                             return BOOLCONSTANT;
 434                         }
 435 false                   {
 436                             yylval->n = 0;
 437                             return BOOLCONSTANT;
 438                         }
 439
 440
 441     /* Reserved words in GLSL 1.10. */
 442 asm             KEYWORD(110, 100, 0, 0, ASM);
 443 class           KEYWORD(110, 100, 0, 0, CLASS);
 444 union           KEYWORD(110, 100, 0, 0, UNION);
 445 enum            KEYWORD(110, 100, 0, 0, ENUM);
 446 typedef         KEYWORD(110, 100, 0, 0, TYPEDEF);
 447 template        KEYWORD(110, 100, 0, 0, TEMPLATE);
 448 this            KEYWORD(110, 100, 0, 0, THIS);
 449 packed          KEYWORD_WITH_ALT(110, 100, 140, 300, yyextra->ARB_uniform_buffer_object_enable, PACKED_TOK);
 450 goto            KEYWORD(110, 100, 0, 0, GOTO);
 451 switch          KEYWORD(110, 100, 130, 300, SWITCH);
 452 default         KEYWORD(110, 100, 130, 300, DEFAULT);
 453 inline          KEYWORD(110, 100, 0, 0, INLINE_TOK);
 454 noinline        KEYWORD(110, 100, 0, 0, NOINLINE);
 455 volatile        KEYWORD(110, 100, 0, 0, VOLATILE);
 456 public          KEYWORD(110, 100, 0, 0, PUBLIC_TOK);
 457 static          KEYWORD(110, 100, 0, 0, STATIC);
 458 extern          KEYWORD(110, 100, 0, 0, EXTERN);
 459 external        KEYWORD(110, 100, 0, 0, EXTERNAL);
 460 interface       KEYWORD(110, 100, 0, 0, INTERFACE);
 461 long            KEYWORD(110, 100, 0, 0, LONG_TOK);
 462 short           KEYWORD(110, 100, 0, 0, SHORT_TOK);
 463 double          KEYWORD(110, 100, 400, 0, DOUBLE_TOK);
 464 half            KEYWORD(110, 100, 0, 0, HALF);
 465 fixed           KEYWORD(110, 100, 0, 0, FIXED_TOK);
 466 unsigned        KEYWORD(110, 100, 0, 0, UNSIGNED);
 467 input           KEYWORD(110, 100, 0, 0, INPUT_TOK);
 468 output          KEYWORD(110, 100, 0, 0, OUTPUT);
 469 hvec2           KEYWORD(110, 100, 0, 0, HVEC2);
 470 hvec3           KEYWORD(110, 100, 0, 0, HVEC3);
 471 hvec4           KEYWORD(110, 100, 0, 0, HVEC4);
 472 dvec2           KEYWORD(110, 100, 400, 0, DVEC2);
 473 dvec3           KEYWORD(110, 100, 400, 0, DVEC3);
 474 dvec4           KEYWORD(110, 100, 400, 0, DVEC4);
 475 fvec2           KEYWORD(110, 100, 0, 0, FVEC2);
 476 fvec3           KEYWORD(110, 100, 0, 0, FVEC3);
 477 fvec4           KEYWORD(110, 100, 0, 0, FVEC4);
 478 sampler2DRect           DEPRECATED_ES_KEYWORD(SAMPLER2DRECT);
 479 sampler3DRect           KEYWORD(110, 100, 0, 0, SAMPLER3DRECT);
 480 sampler2DRectShadow     DEPRECATED_ES_KEYWORD(SAMPLER2DRECTSHADOW);
 481 sizeof          KEYWORD(110, 100, 0, 0, SIZEOF);
 482 cast            KEYWORD(110, 100, 0, 0, CAST);
 483 namespace       KEYWORD(110, 100, 0, 0, NAMESPACE);
 484 using           KEYWORD(110, 100, 0, 0, USING);
 485
 486     /* Additional reserved words in GLSL 1.20. */
 487 lowp            KEYWORD(120, 100, 130, 100, LOWP);
 488 mediump         KEYWORD(120, 100, 130, 100, MEDIUMP);
 489 highp           KEYWORD(120, 100, 130, 100, HIGHP);
 490 precision       KEYWORD(120, 100, 130, 100, PRECISION);
 491
 492     /* Additional reserved words in GLSL 1.30. */
 493 case            KEYWORD(130, 300, 130, 300, CASE);
 494 common          KEYWORD(130, 300, 0, 0, COMMON);
 495 partition       KEYWORD(130, 300, 0, 0, PARTITION);
 496 active          KEYWORD(130, 300, 0, 0, ACTIVE);
 497 superp          KEYWORD(130, 100, 0, 0, SUPERP);
 498 samplerBuffer   KEYWORD(130, 300, 140, 0, SAMPLERBUFFER);
 499 filter          KEYWORD(130, 300, 0, 0, FILTER);
 500 image1D         KEYWORD(130, 300, 0, 0, IMAGE1D);
 501 image2D         KEYWORD(130, 300, 0, 0, IMAGE2D);
 502 image3D         KEYWORD(130, 300, 0, 0, IMAGE3D);
 503 imageCube       KEYWORD(130, 300, 0, 0, IMAGECUBE);
 504 iimage1D        KEYWORD(130, 300, 0, 0, IIMAGE1D);
 505 iimage2D        KEYWORD(130, 300, 0, 0, IIMAGE2D);
 506 iimage3D        KEYWORD(130, 300, 0, 0, IIMAGE3D);
 507 iimageCube      KEYWORD(130, 300, 0, 0, IIMAGECUBE);
 508 uimage1D        KEYWORD(130, 300, 0, 0, UIMAGE1D);
 509 uimage2D        KEYWORD(130, 300, 0, 0, UIMAGE2D);
 510 uimage3D        KEYWORD(130, 300, 0, 0, UIMAGE3D);
 511 uimageCube      KEYWORD(130, 300, 0, 0, UIMAGECUBE);
 512 image1DArray    KEYWORD(130, 300, 0, 0, IMAGE1DARRAY);
 513 image2DArray    KEYWORD(130, 300, 0, 0, IMAGE2DARRAY);
 514 iimage1DArray   KEYWORD(130, 300, 0, 0, IIMAGE1DARRAY);
 515 iimage2DArray   KEYWORD(130, 300, 0, 0, IIMAGE2DARRAY);
 516 uimage1DArray   KEYWORD(130, 300, 0, 0, UIMAGE1DARRAY);
 517 uimage2DArray   KEYWORD(130, 300, 0, 0, UIMAGE2DARRAY);
 518 image1DShadow   KEYWORD(130, 300, 0, 0, IMAGE1DSHADOW);
 519 image2DShadow   KEYWORD(130, 300, 0, 0, IMAGE2DSHADOW);
 520 image1DArrayShadow KEYWORD(130, 300, 0, 0, IMAGE1DARRAYSHADOW);
 521 image2DArrayShadow KEYWORD(130, 300, 0, 0, IMAGE2DARRAYSHADOW);
 522 imageBuffer     KEYWORD(130, 300, 0, 0, IMAGEBUFFER);
 523 iimageBuffer    KEYWORD(130, 300, 0, 0, IIMAGEBUFFER);
 524 uimageBuffer    KEYWORD(130, 300, 0, 0, UIMAGEBUFFER);
 525 row_major       KEYWORD_WITH_ALT(130, 0, 140, 0, yyextra->ARB_uniform_buffer_object_enable, ROW_MAJOR);
 526
 527     /* Additional reserved words in GLSL 1.40 */
 528 isampler2DRect  KEYWORD(140, 300, 140, 0, ISAMPLER2DRECT);
 529 usampler2DRect  KEYWORD(140, 300, 140, 0, USAMPLER2DRECT);
 530 isamplerBuffer  KEYWORD(140, 300, 140, 0, ISAMPLERBUFFER);
 531 usamplerBuffer  KEYWORD(140, 300, 140, 0, USAMPLERBUFFER);
 532
 533     /* Additional reserved words in GLSL ES 3.00 */
 534 coherent        KEYWORD(0, 300, 0, 0, COHERENT);
 535 restrict        KEYWORD(0, 300, 0, 0, RESTRICT);
 536 readonly        KEYWORD(0, 300, 0, 0, READONLY);
 537 writeonly       KEYWORD(0, 300, 0, 0, WRITEONLY);
 538 resource        KEYWORD(0, 300, 0, 0, RESOURCE);
 539 atomic_uint     KEYWORD(0, 300, 0, 0, ATOMIC_UINT);
 540 patch           KEYWORD(0, 300, 0, 0, PATCH);
 541 sample          KEYWORD(0, 300, 0, 0, SAMPLE);
 542 subroutine      KEYWORD(0, 300, 0, 0, SUBROUTINE);
 543
 544
 545 [_a-zA-Z][_a-zA-Z0-9]*  {
 546                             struct _mesa_glsl_parse_state *state = yyextra;
 547                             void *ctx = state;
 548                             yylval->identifier = ralloc_strdup(ctx, yytext);
 549                             return classify_identifier(state, yytext);
 550                         }
 551
 552 .                       { return yytext[0]; }
 553
 554 %%
 555
 556 int
 557 classify_identifier(struct _mesa_glsl_parse_state *state, const char *name)
 558 {
 559    if (state->symbols->get_variable(name) || state->symbols->get_function(name))
 560       return IDENTIFIER;
 561    else if (state->symbols->get_type(name))
 562       return TYPE_IDENTIFIER;
 563    else
 564       return NEW_IDENTIFIER;
 565 }
 566
 567 void
 568 _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string)
 569 {
 570    yylex_init_extra(state, & state->scanner);
 571    yy_scan_string(string, state->scanner);
 572 }
 573
 574 void
 575 _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state)
 576 {
 577    yylex_destroy(state->scanner);
 578 }