Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1901 | serge | 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 |
||
25 | #include "strtod.h" |
||
26 | #include "ast.h" |
||
27 | #include "glsl_parser_extras.h" |
||
28 | #include "glsl_parser.h" |
||
29 | |||
30 | static int classify_identifier(struct _mesa_glsl_parse_state *, const char *); |
||
31 | |||
32 | #define YY_USER_ACTION \ |
||
33 | do { \ |
||
34 | yylloc->source = 0; \ |
||
35 | yylloc->first_column = yycolumn + 1; \ |
||
36 | yylloc->first_line = yylineno + 1; \ |
||
37 | yycolumn += yyleng; \ |
||
38 | } while(0); |
||
39 | |||
40 | #define YY_USER_INIT yylineno = 0; yycolumn = 0; |
||
41 | |||
42 | #define IS_UINT (yytext[yyleng - 1] == 'u' || yytext[yyleng - 1] == 'U') |
||
43 | |||
44 | /* A macro for handling reserved words and keywords across language versions. |
||
45 | * |
||
46 | * Certain words start out as identifiers, become reserved words in |
||
47 | * later language revisions, and finally become language keywords. |
||
48 | * |
||
49 | * For example, consider the following lexer rule: |
||
50 | * samplerBuffer KEYWORD(130, 140, SAMPLERBUFFER) |
||
51 | * |
||
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 |
||
56 | */ |
||
57 | #define KEYWORD(reserved_version, allowed_version, token) \ |
||
58 | do { \ |
||
59 | if (yyextra->language_version >= allowed_version) { \ |
||
60 | return token; \ |
||
61 | } else if (yyextra->language_version >= reserved_version) { \ |
||
62 | _mesa_glsl_error(yylloc, yyextra, \ |
||
63 | "Illegal use of reserved word `%s'", yytext); \ |
||
64 | return ERROR_TOK; \ |
||
65 | } else { \ |
||
66 | yylval->identifier = strdup(yytext); \ |
||
67 | return classify_identifier(yyextra, yytext); \ |
||
68 | } \ |
||
69 | } while (0) |
||
70 | |||
71 | /* The ES macro can be used in KEYWORD checks: |
||
72 | * |
||
73 | * word KEYWORD(110 || ES, 400, TOKEN) |
||
74 | * ...means the word is reserved in GLSL ES 1.00, while |
||
75 | * |
||
76 | * word KEYWORD(110, 130 || ES, TOKEN) |
||
77 | * ...means the word is a legal keyword in GLSL ES 1.00. |
||
78 | */ |
||
79 | #define ES yyextra->es_shader |
||
80 | %} |
||
81 | |||
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 *" |
||
87 | |||
88 | %x PP PRAGMA |
||
89 | |||
90 | DEC_INT [1-9][0-9]* |
||
91 | HEX_INT 0[xX][0-9a-fA-F]+ |
||
92 | OCT_INT 0[0-7]* |
||
93 | INT ({DEC_INT}|{HEX_INT}|{OCT_INT}) |
||
94 | SPC [ \t]* |
||
95 | SPCP [ \t]+ |
||
96 | HASH ^{SPC}#{SPC} |
||
97 | %% |
||
98 | |||
99 | [ \r\t]+ ; |
||
100 | |||
101 | /* Preprocessor tokens. */ |
||
102 | ^[ \t]*#[ \t]*$ ; |
||
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 |
||
107 | * encountered |
||
108 | */ |
||
109 | char *ptr = yytext; |
||
110 | while (!isdigit(*ptr)) |
||
111 | ptr++; |
||
112 | |||
113 | /* Subtract one from the line number because |
||
114 | * yylineno is zero-based instead of |
||
115 | * one-based. |
||
116 | */ |
||
117 | yylineno = strtol(ptr, &ptr, 0) - 1; |
||
118 | yylloc->source = strtol(ptr, NULL, 0); |
||
119 | } |
||
120 | {HASH}line{SPCP}{INT}{SPC}$ { |
||
121 | /* Eat characters until the first digit is |
||
122 | * encountered |
||
123 | */ |
||
124 | char *ptr = yytext; |
||
125 | while (!isdigit(*ptr)) |
||
126 | ptr++; |
||
127 | |||
128 | /* Subtract one from the line number because |
||
129 | * yylineno is zero-based instead of |
||
130 | * one-based. |
||
131 | */ |
||
132 | yylineno = strtol(ptr, &ptr, 0) - 1; |
||
133 | } |
||
134 | ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) { |
||
135 | BEGIN PP; |
||
136 | return PRAGMA_DEBUG_ON; |
||
137 | } |
||
138 | ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) { |
||
139 | BEGIN PP; |
||
140 | return PRAGMA_DEBUG_OFF; |
||
141 | } |
||
142 | ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) { |
||
143 | BEGIN PP; |
||
144 | return PRAGMA_OPTIMIZE_ON; |
||
145 | } |
||
146 | ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) { |
||
147 | BEGIN PP; |
||
148 | return PRAGMA_OPTIMIZE_OFF; |
||
149 | } |
||
150 | ^{SPC}#{SPC}pragma{SPCP}STDGL{SPCP}invariant{SPC}\({SPC}all{SPC}\) { |
||
151 | BEGIN PP; |
||
152 | return PRAGMA_INVARIANT_ALL; |
||
153 | } |
||
154 | ^{SPC}#{SPC}pragma{SPCP} { BEGIN PRAGMA; } |
||
155 | |||
156 |
|
||
157 |
|
||
158 | |||
159 |
|
||
160 |
|
||
161 |
|
||
162 |
|
||
163 | yylval->identifier = strdup(yytext); |
||
164 | return IDENTIFIER; |
||
165 | } |
||
166 |
|
||
167 | yylval->n = strtol(yytext, NULL, 10); |
||
168 | return INTCONSTANT; |
||
169 | } |
||
170 |
|
||
171 | |||
172 | \n { yylineno++; yycolumn = 0; } |
||
173 | |||
174 | attribute return ATTRIBUTE; |
||
175 | const return CONST_TOK; |
||
176 | bool return BOOL_TOK; |
||
177 | float return FLOAT_TOK; |
||
178 | int return INT_TOK; |
||
179 | uint KEYWORD(130, 130, UINT_TOK); |
||
180 | |||
181 | break return BREAK; |
||
182 | continue return CONTINUE; |
||
183 | do return DO; |
||
184 | while return WHILE; |
||
185 | else return ELSE; |
||
186 | for return FOR; |
||
187 | if return IF; |
||
188 | discard return DISCARD; |
||
189 | return return RETURN; |
||
190 | |||
191 | bvec2 return BVEC2; |
||
192 | bvec3 return BVEC3; |
||
193 | bvec4 return BVEC4; |
||
194 | ivec2 return IVEC2; |
||
195 | ivec3 return IVEC3; |
||
196 | ivec4 return IVEC4; |
||
197 | uvec2 KEYWORD(130, 130, UVEC2); |
||
198 | uvec3 KEYWORD(130, 130, UVEC3); |
||
199 | uvec4 KEYWORD(130, 130, UVEC4); |
||
200 | vec2 return VEC2; |
||
201 | vec3 return VEC3; |
||
202 | vec4 return VEC4; |
||
203 | mat2 return MAT2X2; |
||
204 | mat3 return MAT3X3; |
||
205 | mat4 return MAT4X4; |
||
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); |
||
215 | |||
216 | in return IN_TOK; |
||
217 | out return OUT_TOK; |
||
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); |
||
226 | |||
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); |
||
250 | |||
251 | |||
252 | struct return STRUCT; |
||
253 | void return VOID_TOK; |
||
254 | |||
255 | layout { |
||
256 | if ((yyextra->language_version >= 140) |
||
257 | || yyextra->ARB_explicit_attrib_location_enable |
||
258 | || (yyextra->ARB_fragment_coord_conventions_enable)){ |
||
259 | return LAYOUT_TOK; |
||
260 | } else { |
||
261 | yylval->identifier = strdup(yytext); |
||
262 | return IDENTIFIER; |
||
263 | } |
||
264 | } |
||
265 | |||
266 | \+\+ return INC_OP; |
||
267 | -- return DEC_OP; |
||
268 | \<= return LE_OP; |
||
269 | >= return GE_OP; |
||
270 | == return EQ_OP; |
||
271 | != return NE_OP; |
||
272 | && return AND_OP; |
||
273 | \|\| return OR_OP; |
||
274 | "^^" return XOR_OP; |
||
275 | "<<" return LEFT_OP; |
||
276 | ">>" return RIGHT_OP; |
||
277 | |||
278 | \*= return MUL_ASSIGN; |
||
279 | \/= return DIV_ASSIGN; |
||
280 | \+= return ADD_ASSIGN; |
||
281 | \%= return MOD_ASSIGN; |
||
282 | \<\<= return LEFT_ASSIGN; |
||
283 | >>= return RIGHT_ASSIGN; |
||
284 | &= return AND_ASSIGN; |
||
285 | "^=" return XOR_ASSIGN; |
||
286 | \|= return OR_ASSIGN; |
||
287 | -= return SUB_ASSIGN; |
||
288 | |||
289 | [1-9][0-9]*[uU]? { |
||
290 | yylval->n = strtol(yytext, NULL, 10); |
||
291 | return IS_UINT ? UINTCONSTANT : INTCONSTANT; |
||
292 | } |
||
293 | 0[xX][0-9a-fA-F]+[uU]? { |
||
294 | yylval->n = strtol(yytext + 2, NULL, 16); |
||
295 | return IS_UINT ? UINTCONSTANT : INTCONSTANT; |
||
296 | } |
||
297 | 0[0-7]*[uU]? { |
||
298 | yylval->n = strtol(yytext, NULL, 8); |
||
299 | return IS_UINT ? UINTCONSTANT : INTCONSTANT; |
||
300 | } |
||
301 | |||
302 | [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]? { |
||
303 | yylval->real = glsl_strtod(yytext, NULL); |
||
304 | return FLOATCONSTANT; |
||
305 | } |
||
306 | \.[0-9]+([eE][+-]?[0-9]+)?[fF]? { |
||
307 | yylval->real = glsl_strtod(yytext, NULL); |
||
308 | return FLOATCONSTANT; |
||
309 | } |
||
310 | [0-9]+\.([eE][+-]?[0-9]+)?[fF]? { |
||
311 | yylval->real = glsl_strtod(yytext, NULL); |
||
312 | return FLOATCONSTANT; |
||
313 | } |
||
314 | [0-9]+[eE][+-]?[0-9]+[fF]? { |
||
315 | yylval->real = glsl_strtod(yytext, NULL); |
||
316 | return FLOATCONSTANT; |
||
317 | } |
||
318 | [0-9]+[fF] { |
||
319 | yylval->real = glsl_strtod(yytext, NULL); |
||
320 | return FLOATCONSTANT; |
||
321 | } |
||
322 | |||
323 | true { |
||
324 | yylval->n = 1; |
||
325 | return BOOLCONSTANT; |
||
326 | } |
||
327 | false { |
||
328 | yylval->n = 0; |
||
329 | return BOOLCONSTANT; |
||
330 | } |
||
331 | |||
332 | |||
333 | /* Reserved words in GLSL 1.10. */ |
||
334 | asm KEYWORD(110 || ES, 999, ASM); |
||
335 | class KEYWORD(110 || ES, 999, CLASS); |
||
336 | union KEYWORD(110 || ES, 999, UNION); |
||
337 | enum KEYWORD(110 || ES, 999, ENUM); |
||
338 | typedef KEYWORD(110 || ES, 999, TYPEDEF); |
||
339 | template KEYWORD(110 || ES, 999, TEMPLATE); |
||
340 | this KEYWORD(110 || ES, 999, THIS); |
||
341 | packed KEYWORD(110 || ES, 999, PACKED_TOK); |
||
342 | goto KEYWORD(110 || ES, 999, GOTO); |
||
343 | switch KEYWORD(110 || ES, 130, SWITCH); |
||
344 | default KEYWORD(110 || ES, 130, DEFAULT); |
||
345 | inline KEYWORD(110 || ES, 999, INLINE_TOK); |
||
346 | noinline KEYWORD(110 || ES, 999, NOINLINE); |
||
347 | volatile KEYWORD(110 || ES, 999, VOLATILE); |
||
348 | public KEYWORD(110 || ES, 999, PUBLIC_TOK); |
||
349 | static KEYWORD(110 || ES, 999, STATIC); |
||
350 | extern KEYWORD(110 || ES, 999, EXTERN); |
||
351 | external KEYWORD(110 || ES, 999, EXTERNAL); |
||
352 | interface KEYWORD(110 || ES, 999, INTERFACE); |
||
353 | long KEYWORD(110 || ES, 999, LONG_TOK); |
||
354 | short KEYWORD(110 || ES, 999, SHORT_TOK); |
||
355 | double KEYWORD(110 || ES, 400, DOUBLE_TOK); |
||
356 | half KEYWORD(110 || ES, 999, HALF); |
||
357 | fixed KEYWORD(110 || ES, 999, FIXED_TOK); |
||
358 | unsigned KEYWORD(110 || ES, 999, UNSIGNED); |
||
359 | input KEYWORD(110 || ES, 999, INPUT_TOK); |
||
360 | output KEYWORD(110 || ES, 999, OUTPUT); |
||
361 | hvec2 KEYWORD(110 || ES, 999, HVEC2); |
||
362 | hvec3 KEYWORD(110 || ES, 999, HVEC3); |
||
363 | hvec4 KEYWORD(110 || ES, 999, HVEC4); |
||
364 | dvec2 KEYWORD(110 || ES, 400, DVEC2); |
||
365 | dvec3 KEYWORD(110 || ES, 400, DVEC3); |
||
366 | dvec4 KEYWORD(110 || ES, 400, DVEC4); |
||
367 | fvec2 KEYWORD(110 || ES, 999, FVEC2); |
||
368 | fvec3 KEYWORD(110 || ES, 999, FVEC3); |
||
369 | fvec4 KEYWORD(110 || ES, 999, FVEC4); |
||
370 | sampler2DRect return SAMPLER2DRECT; |
||
371 | sampler3DRect KEYWORD(110 || ES, 999, SAMPLER3DRECT); |
||
372 | sampler2DRectShadow return SAMPLER2DRECTSHADOW; |
||
373 | sizeof KEYWORD(110 || ES, 999, SIZEOF); |
||
374 | cast KEYWORD(110 || ES, 999, CAST); |
||
375 | namespace KEYWORD(110 || ES, 999, NAMESPACE); |
||
376 | using KEYWORD(110 || ES, 999, USING); |
||
377 | |||
378 | /* Additional reserved words in GLSL 1.20. */ |
||
379 | lowp KEYWORD(120, 130 || ES, LOWP); |
||
380 | mediump KEYWORD(120, 130 || ES, MEDIUMP); |
||
381 | highp KEYWORD(120, 130 || ES, HIGHP); |
||
382 | precision KEYWORD(120, 130 || ES, PRECISION); |
||
383 | |||
384 | /* Additional reserved words in GLSL 1.30. */ |
||
385 | case KEYWORD(130, 130, CASE); |
||
386 | common KEYWORD(130, 999, COMMON); |
||
387 | partition KEYWORD(130, 999, PARTITION); |
||
388 | active KEYWORD(130, 999, ACTIVE); |
||
389 | superp KEYWORD(130 || ES, 999, SUPERP); |
||
390 | samplerBuffer KEYWORD(130, 140, SAMPLERBUFFER); |
||
391 | filter KEYWORD(130, 999, FILTER); |
||
392 | image1D KEYWORD(130, 999, IMAGE1D); |
||
393 | image2D KEYWORD(130, 999, IMAGE2D); |
||
394 | image3D KEYWORD(130, 999, IMAGE3D); |
||
395 | imageCube KEYWORD(130, 999, IMAGECUBE); |
||
396 | iimage1D KEYWORD(130, 999, IIMAGE1D); |
||
397 | iimage2D KEYWORD(130, 999, IIMAGE2D); |
||
398 | iimage3D KEYWORD(130, 999, IIMAGE3D); |
||
399 | iimageCube KEYWORD(130, 999, IIMAGECUBE); |
||
400 | uimage1D KEYWORD(130, 999, UIMAGE1D); |
||
401 | uimage2D KEYWORD(130, 999, UIMAGE2D); |
||
402 | uimage3D KEYWORD(130, 999, UIMAGE3D); |
||
403 | uimageCube KEYWORD(130, 999, UIMAGECUBE); |
||
404 | image1DArray KEYWORD(130, 999, IMAGE1DARRAY); |
||
405 | image2DArray KEYWORD(130, 999, IMAGE2DARRAY); |
||
406 | iimage1DArray KEYWORD(130, 999, IIMAGE1DARRAY); |
||
407 | iimage2DArray KEYWORD(130, 999, IIMAGE2DARRAY); |
||
408 | uimage1DArray KEYWORD(130, 999, UIMAGE1DARRAY); |
||
409 | uimage2DArray KEYWORD(130, 999, UIMAGE2DARRAY); |
||
410 | image1DShadow KEYWORD(130, 999, IMAGE1DSHADOW); |
||
411 | image2DShadow KEYWORD(130, 999, IMAGE2DSHADOW); |
||
412 | image1DArrayShadow KEYWORD(130, 999, IMAGE1DARRAYSHADOW); |
||
413 | image2DArrayShadow KEYWORD(130, 999, IMAGE2DARRAYSHADOW); |
||
414 | imageBuffer KEYWORD(130, 999, IMAGEBUFFER); |
||
415 | iimageBuffer KEYWORD(130, 999, IIMAGEBUFFER); |
||
416 | uimageBuffer KEYWORD(130, 999, UIMAGEBUFFER); |
||
417 | row_major KEYWORD(130, 999, ROW_MAJOR); |
||
418 | |||
419 | [_a-zA-Z][_a-zA-Z0-9]* { |
||
420 | struct _mesa_glsl_parse_state *state = yyextra; |
||
421 | void *ctx = state; |
||
422 | yylval->identifier = ralloc_strdup(ctx, yytext); |
||
423 | return classify_identifier(state, yytext); |
||
424 | } |
||
425 | |||
426 | . { return yytext[0]; } |
||
427 | |||
428 | %% |
||
429 | |||
430 | int |
||
431 | classify_identifier(struct _mesa_glsl_parse_state *state, const char *name) |
||
432 | { |
||
433 | if (state->symbols->get_variable(name) || state->symbols->get_function(name)) |
||
434 | return IDENTIFIER; |
||
435 | else if (state->symbols->get_type(name)) |
||
436 | return TYPE_IDENTIFIER; |
||
437 | else |
||
438 | return NEW_IDENTIFIER; |
||
439 | } |
||
440 | |||
441 | void |
||
442 | _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string) |
||
443 | { |
||
444 | yylex_init_extra(state, & state->scanner); |
||
445 | yy_scan_string(string, state->scanner); |
||
446 | } |
||
447 | |||
448 | void |
||
449 | _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state) |
||
450 | { |
||
451 | yylex_destroy(state->scanner); |
||
452 | }=>\<=>"><">=>> |