3 * Copyright © 2008, 2009 Intel Corporation
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:
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
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.
27 #include "glsl_parser_extras.h"
28 #include "glsl_parser.h"
30 static int classify_identifier(struct _mesa_glsl_parse_state *, const char *);
32 #define YY_USER_ACTION \
35 yylloc->first_column = yycolumn + 1; \
36 yylloc->first_line = yylineno + 1; \
40 #define YY_USER_INIT yylineno = 0; yycolumn = 0;
42 #define IS_UINT (yytext[yyleng - 1] == 'u' || yytext[yyleng - 1] == 'U')
44 /* A macro for handling reserved words and keywords across language versions.
46 * Certain words start out as identifiers, become reserved words in
47 * later language revisions, and finally become language keywords.
49 * For example, consider the following lexer rule:
50 * samplerBuffer KEYWORD(130, 140, SAMPLERBUFFER)
52 * This means that "samplerBuffer" will be treated as:
53 * - a keyword (SAMPLERBUFFER token) ...in GLSL >= 1.40
54 * - a reserved word - error ...in GLSL >= 1.30
55 * - an identifier ...in GLSL < 1.30
57 #define KEYWORD(reserved_version, allowed_version, token) \
59 if (yyextra->language_version >= allowed_version) { \
61 } else if (yyextra->language_version >= reserved_version) { \
62 _mesa_glsl_error(yylloc, yyextra, \
63 "Illegal use of reserved word `%s'", yytext); \
66 yylval->identifier = strdup(yytext); \
67 return classify_identifier(yyextra, yytext); \
71 /* The ES macro can be used in KEYWORD checks:
73 * word KEYWORD(110 || ES, 400, TOKEN)
74 * ...means the word is reserved in GLSL ES 1.00, while
76 * word KEYWORD(110, 130 || ES, TOKEN)
77 * ...means the word is a legal keyword in GLSL ES 1.00.
79 #define ES yyextra->es_shader
82 %option bison-bridge bison-locations reentrant noyywrap
83 %option nounput noyy_top_state
84 %option never-interactive
85 %option prefix="_mesa_glsl_"
86 %option extra-type="struct _mesa_glsl_parse_state *"
91 HEX_INT 0[xX][0-9a-fA-F]+
93 INT ({DEC_INT}|{HEX_INT}|{OCT_INT})
101 /* Preprocessor tokens. */
103 ^[ \t]*#[ \t]*version { BEGIN PP; return VERSION; }
104 ^[ \t]*#[ \t]*extension { BEGIN PP; return EXTENSION; }
105 {HASH}line{SPCP}{INT}{SPCP}{INT}{SPC}$ {
106 /* Eat characters until the first digit is
110 while (!isdigit(*ptr))
113 /* Subtract one from the line number because
114 * yylineno is zero-based instead of
117 yylineno = strtol(ptr, &ptr, 0) - 1;
118 yylloc->source = strtol(ptr, NULL, 0);
120 {HASH}line{SPCP}{INT}{SPC}$ {
121 /* Eat characters until the first digit is
125 while (!isdigit(*ptr))
128 /* Subtract one from the line number because
129 * yylineno is zero-based instead of
132 yylineno = strtol(ptr, &ptr, 0) - 1;
134 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) {
136 return PRAGMA_DEBUG_ON;
138 ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) {
140 return PRAGMA_DEBUG_OFF;
142 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) {
144 return PRAGMA_OPTIMIZE_ON;
146 ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) {
148 return PRAGMA_OPTIMIZE_OFF;
150 ^{SPC}#{SPC}pragma{SPCP}STDGL{SPCP}invariant{SPC}\({SPC}all{SPC}\) {
152 return PRAGMA_INVARIANT_ALL;
154 ^{SPC}#{SPC}pragma{SPCP} { BEGIN PRAGMA; }
156 <PRAGMA>\n { BEGIN 0; yylineno++; yycolumn = 0; }
162 <PP>[_a-zA-Z][_a-zA-Z0-9]* {
163 yylval->identifier = strdup(yytext);
167 yylval->n = strtol(yytext, NULL, 10);
170 <PP>\n { BEGIN 0; yylineno++; yycolumn = 0; return EOL; }
172 \n { yylineno++; yycolumn = 0; }
174 attribute return ATTRIBUTE;
175 const return CONST_TOK;
176 bool return BOOL_TOK;
177 float return FLOAT_TOK;
179 uint KEYWORD(130, 130, UINT_TOK);
182 continue return CONTINUE;
188 discard return DISCARD;
189 return return RETURN;
197 uvec2 KEYWORD(130, 130, UVEC2);
198 uvec3 KEYWORD(130, 130, UVEC3);
199 uvec4 KEYWORD(130, 130, UVEC4);
206 mat2x2 KEYWORD(120, 120, MAT2X2);
207 mat2x3 KEYWORD(120, 120, MAT2X3);
208 mat2x4 KEYWORD(120, 120, MAT2X4);
209 mat3x2 KEYWORD(120, 120, MAT3X2);
210 mat3x3 KEYWORD(120, 120, MAT3X3);
211 mat3x4 KEYWORD(120, 120, MAT3X4);
212 mat4x2 KEYWORD(120, 120, MAT4X2);
213 mat4x3 KEYWORD(120, 120, MAT4X3);
214 mat4x4 KEYWORD(120, 120, MAT4X4);
218 inout return INOUT_TOK;
219 uniform return UNIFORM;
220 varying return VARYING;
221 centroid KEYWORD(120, 120, CENTROID);
222 invariant KEYWORD(120 || ES, 120 || ES, INVARIANT);
223 flat KEYWORD(130 || ES, 130, FLAT);
224 smooth KEYWORD(130, 130, SMOOTH);
225 noperspective KEYWORD(130, 130, NOPERSPECTIVE);
227 sampler1D return SAMPLER1D;
228 sampler2D return SAMPLER2D;
229 sampler3D return SAMPLER3D;
230 samplerCube return SAMPLERCUBE;
231 sampler1DArray KEYWORD(130, 130, SAMPLER1DARRAY);
232 sampler2DArray KEYWORD(130, 130, SAMPLER2DARRAY);
233 sampler1DShadow return SAMPLER1DSHADOW;
234 sampler2DShadow return SAMPLER2DSHADOW;
235 samplerCubeShadow KEYWORD(130, 130, SAMPLERCUBESHADOW);
236 sampler1DArrayShadow KEYWORD(130, 130, SAMPLER1DARRAYSHADOW);
237 sampler2DArrayShadow KEYWORD(130, 130, SAMPLER2DARRAYSHADOW);
238 isampler1D KEYWORD(130, 130, ISAMPLER1D);
239 isampler2D KEYWORD(130, 130, ISAMPLER2D);
240 isampler3D KEYWORD(130, 130, ISAMPLER3D);
241 isamplerCube KEYWORD(130, 130, ISAMPLERCUBE);
242 isampler1DArray KEYWORD(130, 130, ISAMPLER1DARRAY);
243 isampler2DArray KEYWORD(130, 130, ISAMPLER2DARRAY);
244 usampler1D KEYWORD(130, 130, USAMPLER1D);
245 usampler2D KEYWORD(130, 130, USAMPLER2D);
246 usampler3D KEYWORD(130, 130, USAMPLER3D);
247 usamplerCube KEYWORD(130, 130, USAMPLERCUBE);
248 usampler1DArray KEYWORD(130, 130, USAMPLER1DARRAY);
249 usampler2DArray KEYWORD(130, 130, USAMPLER2DARRAY);
252 struct return STRUCT;
253 void return VOID_TOK;
256 if ((yyextra->language_version >= 140)
257 || yyextra->AMD_conservative_depth_enable
258 || yyextra->ARB_explicit_attrib_location_enable
259 || yyextra->ARB_fragment_coord_conventions_enable) {
262 yylval->identifier = strdup(yytext);
277 ">>" return RIGHT_OP;
279 \*= return MUL_ASSIGN;
280 \/= return DIV_ASSIGN;
281 \+= return ADD_ASSIGN;
282 \%= return MOD_ASSIGN;
283 \<\<= return LEFT_ASSIGN;
284 >>= return RIGHT_ASSIGN;
285 &= return AND_ASSIGN;
286 "^=" return XOR_ASSIGN;
287 \|= return OR_ASSIGN;
288 -= return SUB_ASSIGN;
291 yylval->n = strtol(yytext, NULL, 10);
292 return IS_UINT ? UINTCONSTANT : INTCONSTANT;
294 0[xX][0-9a-fA-F]+[uU]? {
295 yylval->n = strtol(yytext + 2, NULL, 16);
296 return IS_UINT ? UINTCONSTANT : INTCONSTANT;
299 yylval->n = strtol(yytext, NULL, 8);
300 return IS_UINT ? UINTCONSTANT : INTCONSTANT;
303 [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]? {
304 yylval->real = glsl_strtod(yytext, NULL);
305 return FLOATCONSTANT;
307 \.[0-9]+([eE][+-]?[0-9]+)?[fF]? {
308 yylval->real = glsl_strtod(yytext, NULL);
309 return FLOATCONSTANT;
311 [0-9]+\.([eE][+-]?[0-9]+)?[fF]? {
312 yylval->real = glsl_strtod(yytext, NULL);
313 return FLOATCONSTANT;
315 [0-9]+[eE][+-]?[0-9]+[fF]? {
316 yylval->real = glsl_strtod(yytext, NULL);
317 return FLOATCONSTANT;
320 yylval->real = glsl_strtod(yytext, NULL);
321 return FLOATCONSTANT;
334 /* Reserved words in GLSL 1.10. */
335 asm KEYWORD(110 || ES, 999, ASM);
336 class KEYWORD(110 || ES, 999, CLASS);
337 union KEYWORD(110 || ES, 999, UNION);
338 enum KEYWORD(110 || ES, 999, ENUM);
339 typedef KEYWORD(110 || ES, 999, TYPEDEF);
340 template KEYWORD(110 || ES, 999, TEMPLATE);
341 this KEYWORD(110 || ES, 999, THIS);
342 packed KEYWORD(110 || ES, 999, PACKED_TOK);
343 goto KEYWORD(110 || ES, 999, GOTO);
344 switch KEYWORD(110 || ES, 130, SWITCH);
345 default KEYWORD(110 || ES, 130, DEFAULT);
346 inline KEYWORD(110 || ES, 999, INLINE_TOK);
347 noinline KEYWORD(110 || ES, 999, NOINLINE);
348 volatile KEYWORD(110 || ES, 999, VOLATILE);
349 public KEYWORD(110 || ES, 999, PUBLIC_TOK);
350 static KEYWORD(110 || ES, 999, STATIC);
351 extern KEYWORD(110 || ES, 999, EXTERN);
352 external KEYWORD(110 || ES, 999, EXTERNAL);
353 interface KEYWORD(110 || ES, 999, INTERFACE);
354 long KEYWORD(110 || ES, 999, LONG_TOK);
355 short KEYWORD(110 || ES, 999, SHORT_TOK);
356 double KEYWORD(110 || ES, 400, DOUBLE_TOK);
357 half KEYWORD(110 || ES, 999, HALF);
358 fixed KEYWORD(110 || ES, 999, FIXED_TOK);
359 unsigned KEYWORD(110 || ES, 999, UNSIGNED);
360 input KEYWORD(110 || ES, 999, INPUT_TOK);
361 output KEYWORD(110 || ES, 999, OUTPUT);
362 hvec2 KEYWORD(110 || ES, 999, HVEC2);
363 hvec3 KEYWORD(110 || ES, 999, HVEC3);
364 hvec4 KEYWORD(110 || ES, 999, HVEC4);
365 dvec2 KEYWORD(110 || ES, 400, DVEC2);
366 dvec3 KEYWORD(110 || ES, 400, DVEC3);
367 dvec4 KEYWORD(110 || ES, 400, DVEC4);
368 fvec2 KEYWORD(110 || ES, 999, FVEC2);
369 fvec3 KEYWORD(110 || ES, 999, FVEC3);
370 fvec4 KEYWORD(110 || ES, 999, FVEC4);
371 sampler2DRect return SAMPLER2DRECT;
372 sampler3DRect KEYWORD(110 || ES, 999, SAMPLER3DRECT);
373 sampler2DRectShadow return SAMPLER2DRECTSHADOW;
374 sizeof KEYWORD(110 || ES, 999, SIZEOF);
375 cast KEYWORD(110 || ES, 999, CAST);
376 namespace KEYWORD(110 || ES, 999, NAMESPACE);
377 using KEYWORD(110 || ES, 999, USING);
379 /* Additional reserved words in GLSL 1.20. */
380 lowp KEYWORD(120, 130 || ES, LOWP);
381 mediump KEYWORD(120, 130 || ES, MEDIUMP);
382 highp KEYWORD(120, 130 || ES, HIGHP);
383 precision KEYWORD(120, 130 || ES, PRECISION);
385 /* Additional reserved words in GLSL 1.30. */
386 case KEYWORD(130, 130, CASE);
387 common KEYWORD(130, 999, COMMON);
388 partition KEYWORD(130, 999, PARTITION);
389 active KEYWORD(130, 999, ACTIVE);
390 superp KEYWORD(130 || ES, 999, SUPERP);
391 samplerBuffer KEYWORD(130, 140, SAMPLERBUFFER);
392 filter KEYWORD(130, 999, FILTER);
393 image1D KEYWORD(130, 999, IMAGE1D);
394 image2D KEYWORD(130, 999, IMAGE2D);
395 image3D KEYWORD(130, 999, IMAGE3D);
396 imageCube KEYWORD(130, 999, IMAGECUBE);
397 iimage1D KEYWORD(130, 999, IIMAGE1D);
398 iimage2D KEYWORD(130, 999, IIMAGE2D);
399 iimage3D KEYWORD(130, 999, IIMAGE3D);
400 iimageCube KEYWORD(130, 999, IIMAGECUBE);
401 uimage1D KEYWORD(130, 999, UIMAGE1D);
402 uimage2D KEYWORD(130, 999, UIMAGE2D);
403 uimage3D KEYWORD(130, 999, UIMAGE3D);
404 uimageCube KEYWORD(130, 999, UIMAGECUBE);
405 image1DArray KEYWORD(130, 999, IMAGE1DARRAY);
406 image2DArray KEYWORD(130, 999, IMAGE2DARRAY);
407 iimage1DArray KEYWORD(130, 999, IIMAGE1DARRAY);
408 iimage2DArray KEYWORD(130, 999, IIMAGE2DARRAY);
409 uimage1DArray KEYWORD(130, 999, UIMAGE1DARRAY);
410 uimage2DArray KEYWORD(130, 999, UIMAGE2DARRAY);
411 image1DShadow KEYWORD(130, 999, IMAGE1DSHADOW);
412 image2DShadow KEYWORD(130, 999, IMAGE2DSHADOW);
413 image1DArrayShadow KEYWORD(130, 999, IMAGE1DARRAYSHADOW);
414 image2DArrayShadow KEYWORD(130, 999, IMAGE2DARRAYSHADOW);
415 imageBuffer KEYWORD(130, 999, IMAGEBUFFER);
416 iimageBuffer KEYWORD(130, 999, IIMAGEBUFFER);
417 uimageBuffer KEYWORD(130, 999, UIMAGEBUFFER);
418 row_major KEYWORD(130, 999, ROW_MAJOR);
420 [_a-zA-Z][_a-zA-Z0-9]* {
421 struct _mesa_glsl_parse_state *state = yyextra;
423 yylval->identifier = ralloc_strdup(ctx, yytext);
424 return classify_identifier(state, yytext);
427 . { return yytext[0]; }
432 classify_identifier(struct _mesa_glsl_parse_state *state, const char *name)
434 if (state->symbols->get_variable(name) || state->symbols->get_function(name))
436 else if (state->symbols->get_type(name))
437 return TYPE_IDENTIFIER;
439 return NEW_IDENTIFIER;
443 _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string)
445 yylex_init_extra(state, & state->scanner);
446 yy_scan_string(string, state->scanner);
450 _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state)
452 yylex_destroy(state->scanner);