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