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