Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1901 | serge | 1 | /* -*- c++ -*- */ |
2 | /* |
||
3 | * Copyright © 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 | |||
25 | #pragma once |
||
26 | #ifndef AST_H |
||
27 | #define AST_H |
||
28 | |||
29 | #include "list.h" |
||
30 | #include "glsl_parser_extras.h" |
||
31 | |||
32 | struct _mesa_glsl_parse_state; |
||
33 | |||
34 | struct YYLTYPE; |
||
35 | |||
36 | /** |
||
37 | * \defgroup AST Abstract syntax tree node definitions |
||
38 | * |
||
39 | * An abstract syntax tree is generated by the parser. This is a fairly |
||
40 | * direct representation of the gramma derivation for the source program. |
||
41 | * No symantic checking is done during the generation of the AST. Only |
||
42 | * syntactic checking is done. Symantic checking is performed by a later |
||
43 | * stage that converts the AST to a more generic intermediate representation. |
||
44 | * |
||
45 | *@{ |
||
46 | */ |
||
47 | /** |
||
48 | * Base class of all abstract syntax tree nodes |
||
49 | */ |
||
50 | class ast_node { |
||
51 | public: |
||
52 | /* Callers of this ralloc-based new need not call delete. It's |
||
53 | * easier to just ralloc_free 'ctx' (or any of its ancestors). */ |
||
54 | static void* operator new(size_t size, void *ctx) |
||
55 | { |
||
56 | void *node; |
||
57 | |||
58 | node = rzalloc_size(ctx, size); |
||
59 | assert(node != NULL); |
||
60 | |||
61 | return node; |
||
62 | } |
||
63 | |||
64 | /* If the user *does* call delete, that's OK, we will just |
||
65 | * ralloc_free in that case. */ |
||
66 | static void operator delete(void *table) |
||
67 | { |
||
68 | ralloc_free(table); |
||
69 | } |
||
70 | |||
71 | /** |
||
72 | * Print an AST node in something approximating the original GLSL code |
||
73 | */ |
||
74 | virtual void print(void) const; |
||
75 | |||
76 | /** |
||
77 | * Convert the AST node to the high-level intermediate representation |
||
78 | */ |
||
79 | virtual ir_rvalue *hir(exec_list *instructions, |
||
80 | struct _mesa_glsl_parse_state *state); |
||
81 | |||
82 | /** |
||
83 | * Retrieve the source location of an AST node |
||
84 | * |
||
85 | * This function is primarily used to get the source position of an AST node |
||
86 | * into a form that can be passed to \c _mesa_glsl_error. |
||
87 | * |
||
88 | * \sa _mesa_glsl_error, ast_node::set_location |
||
89 | */ |
||
90 | struct YYLTYPE get_location(void) const |
||
91 | { |
||
92 | struct YYLTYPE locp; |
||
93 | |||
94 | locp.source = this->location.source; |
||
95 | locp.first_line = this->location.line; |
||
96 | locp.first_column = this->location.column; |
||
97 | locp.last_line = locp.first_line; |
||
98 | locp.last_column = locp.first_column; |
||
99 | |||
100 | return locp; |
||
101 | } |
||
102 | |||
103 | /** |
||
104 | * Set the source location of an AST node from a parser location |
||
105 | * |
||
106 | * \sa ast_node::get_location |
||
107 | */ |
||
108 | void set_location(const struct YYLTYPE &locp) |
||
109 | { |
||
110 | this->location.source = locp.source; |
||
111 | this->location.line = locp.first_line; |
||
112 | this->location.column = locp.first_column; |
||
113 | } |
||
114 | |||
115 | /** |
||
116 | * Source location of the AST node. |
||
117 | */ |
||
118 | struct { |
||
119 | unsigned source; /**< GLSL source number. */ |
||
120 | unsigned line; /**< Line number within the source string. */ |
||
121 | unsigned column; /**< Column in the line. */ |
||
122 | } location; |
||
123 | |||
124 | exec_node link; |
||
125 | |||
126 | protected: |
||
127 | /** |
||
128 | * The only constructor is protected so that only derived class objects can |
||
129 | * be created. |
||
130 | */ |
||
131 | ast_node(void); |
||
132 | }; |
||
133 | |||
134 | |||
135 | /** |
||
136 | * Operators for AST expression nodes. |
||
137 | */ |
||
138 | enum ast_operators { |
||
139 | ast_assign, |
||
140 | ast_plus, /**< Unary + operator. */ |
||
141 | ast_neg, |
||
142 | ast_add, |
||
143 | ast_sub, |
||
144 | ast_mul, |
||
145 | ast_div, |
||
146 | ast_mod, |
||
147 | ast_lshift, |
||
148 | ast_rshift, |
||
149 | ast_less, |
||
150 | ast_greater, |
||
151 | ast_lequal, |
||
152 | ast_gequal, |
||
153 | ast_equal, |
||
154 | ast_nequal, |
||
155 | ast_bit_and, |
||
156 | ast_bit_xor, |
||
157 | ast_bit_or, |
||
158 | ast_bit_not, |
||
159 | ast_logic_and, |
||
160 | ast_logic_xor, |
||
161 | ast_logic_or, |
||
162 | ast_logic_not, |
||
163 | |||
164 | ast_mul_assign, |
||
165 | ast_div_assign, |
||
166 | ast_mod_assign, |
||
167 | ast_add_assign, |
||
168 | ast_sub_assign, |
||
169 | ast_ls_assign, |
||
170 | ast_rs_assign, |
||
171 | ast_and_assign, |
||
172 | ast_xor_assign, |
||
173 | ast_or_assign, |
||
174 | |||
175 | ast_conditional, |
||
176 | |||
177 | ast_pre_inc, |
||
178 | ast_pre_dec, |
||
179 | ast_post_inc, |
||
180 | ast_post_dec, |
||
181 | ast_field_selection, |
||
182 | ast_array_index, |
||
183 | |||
184 | ast_function_call, |
||
185 | |||
186 | ast_identifier, |
||
187 | ast_int_constant, |
||
188 | ast_uint_constant, |
||
189 | ast_float_constant, |
||
190 | ast_bool_constant, |
||
191 | |||
192 | ast_sequence |
||
193 | }; |
||
194 | |||
195 | /** |
||
196 | * Representation of any sort of expression. |
||
197 | */ |
||
198 | class ast_expression : public ast_node { |
||
199 | public: |
||
200 | ast_expression(int oper, ast_expression *, |
||
201 | ast_expression *, ast_expression *); |
||
202 | |||
203 | ast_expression(const char *identifier) : |
||
204 | oper(ast_identifier) |
||
205 | { |
||
206 | subexpressions[0] = NULL; |
||
207 | subexpressions[1] = NULL; |
||
208 | subexpressions[2] = NULL; |
||
209 | primary_expression.identifier = (char *) identifier; |
||
210 | } |
||
211 | |||
212 | static const char *operator_string(enum ast_operators op); |
||
213 | |||
214 | virtual ir_rvalue *hir(exec_list *instructions, |
||
215 | struct _mesa_glsl_parse_state *state); |
||
216 | |||
217 | virtual void print(void) const; |
||
218 | |||
219 | enum ast_operators oper; |
||
220 | |||
221 | ast_expression *subexpressions[3]; |
||
222 | |||
223 | union { |
||
224 | char *identifier; |
||
225 | int int_constant; |
||
226 | float float_constant; |
||
227 | unsigned uint_constant; |
||
228 | int bool_constant; |
||
229 | } primary_expression; |
||
230 | |||
231 | |||
232 | /** |
||
233 | * List of expressions for an \c ast_sequence or parameters for an |
||
234 | * \c ast_function_call |
||
235 | */ |
||
236 | exec_list expressions; |
||
237 | }; |
||
238 | |||
239 | class ast_expression_bin : public ast_expression { |
||
240 | public: |
||
241 | ast_expression_bin(int oper, ast_expression *, ast_expression *); |
||
242 | |||
243 | virtual void print(void) const; |
||
244 | }; |
||
245 | |||
246 | /** |
||
247 | * Subclass of expressions for function calls |
||
248 | */ |
||
249 | class ast_function_expression : public ast_expression { |
||
250 | public: |
||
251 | ast_function_expression(ast_expression *callee) |
||
252 | : ast_expression(ast_function_call, callee, |
||
253 | NULL, NULL), |
||
254 | cons(false) |
||
255 | { |
||
256 | /* empty */ |
||
257 | } |
||
258 | |||
259 | ast_function_expression(class ast_type_specifier *type) |
||
260 | : ast_expression(ast_function_call, (ast_expression *) type, |
||
261 | NULL, NULL), |
||
262 | cons(true) |
||
263 | { |
||
264 | /* empty */ |
||
265 | } |
||
266 | |||
267 | bool is_constructor() const |
||
268 | { |
||
269 | return cons; |
||
270 | } |
||
271 | |||
272 | virtual ir_rvalue *hir(exec_list *instructions, |
||
273 | struct _mesa_glsl_parse_state *state); |
||
274 | |||
275 | private: |
||
276 | /** |
||
277 | * Is this function call actually a constructor? |
||
278 | */ |
||
279 | bool cons; |
||
280 | }; |
||
281 | |||
282 | |||
283 | /** |
||
284 | * Number of possible operators for an ast_expression |
||
285 | * |
||
286 | * This is done as a define instead of as an additional value in the enum so |
||
287 | * that the compiler won't generate spurious messages like "warning: |
||
288 | * enumeration value ‘ast_num_operators’ not handled in switch" |
||
289 | */ |
||
290 | #define AST_NUM_OPERATORS (ast_sequence + 1) |
||
291 | |||
292 | |||
293 | class ast_compound_statement : public ast_node { |
||
294 | public: |
||
295 | ast_compound_statement(int new_scope, ast_node *statements); |
||
296 | virtual void print(void) const; |
||
297 | |||
298 | virtual ir_rvalue *hir(exec_list *instructions, |
||
299 | struct _mesa_glsl_parse_state *state); |
||
300 | |||
301 | int new_scope; |
||
302 | exec_list statements; |
||
303 | }; |
||
304 | |||
305 | class ast_declaration : public ast_node { |
||
306 | public: |
||
307 | ast_declaration(char *identifier, int is_array, ast_expression *array_size, |
||
308 | ast_expression *initializer); |
||
309 | virtual void print(void) const; |
||
310 | |||
311 | char *identifier; |
||
312 | |||
313 | int is_array; |
||
314 | ast_expression *array_size; |
||
315 | |||
316 | ast_expression *initializer; |
||
317 | }; |
||
318 | |||
319 | |||
320 | enum { |
||
321 | ast_precision_none = 0, /**< Absence of precision qualifier. */ |
||
322 | ast_precision_high, |
||
323 | ast_precision_medium, |
||
324 | ast_precision_low |
||
325 | }; |
||
326 | |||
327 | struct ast_type_qualifier { |
||
328 | union { |
||
329 | struct { |
||
330 | unsigned invariant:1; |
||
331 | unsigned constant:1; |
||
332 | unsigned attribute:1; |
||
333 | unsigned varying:1; |
||
334 | unsigned in:1; |
||
335 | unsigned out:1; |
||
336 | unsigned centroid:1; |
||
337 | unsigned uniform:1; |
||
338 | unsigned smooth:1; |
||
339 | unsigned flat:1; |
||
340 | unsigned noperspective:1; |
||
341 | |||
342 | /** \name Layout qualifiers for GL_ARB_fragment_coord_conventions */ |
||
343 | /*@{*/ |
||
344 | unsigned origin_upper_left:1; |
||
345 | unsigned pixel_center_integer:1; |
||
346 | /*@}*/ |
||
347 | |||
348 | /** |
||
349 | * Flag set if GL_ARB_explicit_attrib_location "location" layout |
||
350 | * qualifier is used. |
||
351 | */ |
||
352 | unsigned explicit_location:1; |
||
353 | } q; |
||
354 | unsigned i; |
||
355 | } flags; |
||
356 | |||
357 | /** |
||
358 | * Location specified via GL_ARB_explicit_attrib_location layout |
||
359 | * |
||
360 | * \note |
||
361 | * This field is only valid if \c explicit_location is set. |
||
362 | */ |
||
363 | unsigned location; |
||
364 | }; |
||
365 | |||
366 | class ast_struct_specifier : public ast_node { |
||
367 | public: |
||
368 | ast_struct_specifier(char *identifier, ast_node *declarator_list); |
||
369 | virtual void print(void) const; |
||
370 | |||
371 | virtual ir_rvalue *hir(exec_list *instructions, |
||
372 | struct _mesa_glsl_parse_state *state); |
||
373 | |||
374 | char *name; |
||
375 | exec_list declarations; |
||
376 | }; |
||
377 | |||
378 | |||
379 | enum ast_types { |
||
380 | ast_void, |
||
381 | ast_float, |
||
382 | ast_int, |
||
383 | ast_uint, |
||
384 | ast_bool, |
||
385 | ast_vec2, |
||
386 | ast_vec3, |
||
387 | ast_vec4, |
||
388 | ast_bvec2, |
||
389 | ast_bvec3, |
||
390 | ast_bvec4, |
||
391 | ast_ivec2, |
||
392 | ast_ivec3, |
||
393 | ast_ivec4, |
||
394 | ast_uvec2, |
||
395 | ast_uvec3, |
||
396 | ast_uvec4, |
||
397 | ast_mat2, |
||
398 | ast_mat2x3, |
||
399 | ast_mat2x4, |
||
400 | ast_mat3x2, |
||
401 | ast_mat3, |
||
402 | ast_mat3x4, |
||
403 | ast_mat4x2, |
||
404 | ast_mat4x3, |
||
405 | ast_mat4, |
||
406 | ast_sampler1d, |
||
407 | ast_sampler2d, |
||
408 | ast_sampler2drect, |
||
409 | ast_sampler3d, |
||
410 | ast_samplercube, |
||
411 | ast_sampler1dshadow, |
||
412 | ast_sampler2dshadow, |
||
413 | ast_sampler2drectshadow, |
||
414 | ast_samplercubeshadow, |
||
415 | ast_sampler1darray, |
||
416 | ast_sampler2darray, |
||
417 | ast_sampler1darrayshadow, |
||
418 | ast_sampler2darrayshadow, |
||
419 | ast_isampler1d, |
||
420 | ast_isampler2d, |
||
421 | ast_isampler3d, |
||
422 | ast_isamplercube, |
||
423 | ast_isampler1darray, |
||
424 | ast_isampler2darray, |
||
425 | ast_usampler1d, |
||
426 | ast_usampler2d, |
||
427 | ast_usampler3d, |
||
428 | ast_usamplercube, |
||
429 | ast_usampler1darray, |
||
430 | ast_usampler2darray, |
||
431 | |||
432 | ast_struct, |
||
433 | ast_type_name |
||
434 | }; |
||
435 | |||
436 | |||
437 | class ast_type_specifier : public ast_node { |
||
438 | public: |
||
439 | ast_type_specifier(int specifier); |
||
440 | |||
441 | /** Construct a type specifier from a type name */ |
||
442 | ast_type_specifier(const char *name) |
||
443 | : type_specifier(ast_type_name), type_name(name), structure(NULL), |
||
444 | is_array(false), array_size(NULL), precision(ast_precision_none), |
||
445 | is_precision_statement(false) |
||
446 | { |
||
447 | /* empty */ |
||
448 | } |
||
449 | |||
450 | /** Construct a type specifier from a structure definition */ |
||
451 | ast_type_specifier(ast_struct_specifier *s) |
||
452 | : type_specifier(ast_struct), type_name(s->name), structure(s), |
||
453 | is_array(false), array_size(NULL), precision(ast_precision_none), |
||
454 | is_precision_statement(false) |
||
455 | { |
||
456 | /* empty */ |
||
457 | } |
||
458 | |||
459 | const struct glsl_type *glsl_type(const char **name, |
||
460 | struct _mesa_glsl_parse_state *state) |
||
461 | const; |
||
462 | |||
463 | virtual void print(void) const; |
||
464 | |||
465 | ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *); |
||
466 | |||
467 | enum ast_types type_specifier; |
||
468 | |||
469 | const char *type_name; |
||
470 | ast_struct_specifier *structure; |
||
471 | |||
472 | int is_array; |
||
473 | ast_expression *array_size; |
||
474 | |||
475 | unsigned precision:2; |
||
476 | |||
477 | bool is_precision_statement; |
||
478 | }; |
||
479 | |||
480 | |||
481 | class ast_fully_specified_type : public ast_node { |
||
482 | public: |
||
483 | virtual void print(void) const; |
||
484 | bool has_qualifiers() const; |
||
485 | |||
486 | ast_type_qualifier qualifier; |
||
487 | ast_type_specifier *specifier; |
||
488 | }; |
||
489 | |||
490 | |||
491 | class ast_declarator_list : public ast_node { |
||
492 | public: |
||
493 | ast_declarator_list(ast_fully_specified_type *); |
||
494 | virtual void print(void) const; |
||
495 | |||
496 | virtual ir_rvalue *hir(exec_list *instructions, |
||
497 | struct _mesa_glsl_parse_state *state); |
||
498 | |||
499 | ast_fully_specified_type *type; |
||
500 | exec_list declarations; |
||
501 | |||
502 | /** |
||
503 | * Special flag for vertex shader "invariant" declarations. |
||
504 | * |
||
505 | * Vertex shaders can contain "invariant" variable redeclarations that do |
||
506 | * not include a type. For example, "invariant gl_Position;". This flag |
||
507 | * is used to note these cases when no type is specified. |
||
508 | */ |
||
509 | int invariant; |
||
510 | }; |
||
511 | |||
512 | |||
513 | class ast_parameter_declarator : public ast_node { |
||
514 | public: |
||
515 | ast_parameter_declarator() |
||
516 | { |
||
517 | this->identifier = NULL; |
||
518 | this->is_array = false; |
||
519 | this->array_size = 0; |
||
520 | } |
||
521 | |||
522 | virtual void print(void) const; |
||
523 | |||
524 | virtual ir_rvalue *hir(exec_list *instructions, |
||
525 | struct _mesa_glsl_parse_state *state); |
||
526 | |||
527 | ast_fully_specified_type *type; |
||
528 | char *identifier; |
||
529 | int is_array; |
||
530 | ast_expression *array_size; |
||
531 | |||
532 | static void parameters_to_hir(exec_list *ast_parameters, |
||
533 | bool formal, exec_list *ir_parameters, |
||
534 | struct _mesa_glsl_parse_state *state); |
||
535 | |||
536 | private: |
||
537 | /** Is this parameter declaration part of a formal parameter list? */ |
||
538 | bool formal_parameter; |
||
539 | |||
540 | /** |
||
541 | * Is this parameter 'void' type? |
||
542 | * |
||
543 | * This field is set by \c ::hir. |
||
544 | */ |
||
545 | bool is_void; |
||
546 | }; |
||
547 | |||
548 | |||
549 | class ast_function : public ast_node { |
||
550 | public: |
||
551 | ast_function(void); |
||
552 | |||
553 | virtual void print(void) const; |
||
554 | |||
555 | virtual ir_rvalue *hir(exec_list *instructions, |
||
556 | struct _mesa_glsl_parse_state *state); |
||
557 | |||
558 | ast_fully_specified_type *return_type; |
||
559 | char *identifier; |
||
560 | |||
561 | exec_list parameters; |
||
562 | |||
563 | private: |
||
564 | /** |
||
565 | * Is this prototype part of the function definition? |
||
566 | * |
||
567 | * Used by ast_function_definition::hir to process the parameters, etc. |
||
568 | * of the function. |
||
569 | * |
||
570 | * \sa ::hir |
||
571 | */ |
||
572 | bool is_definition; |
||
573 | |||
574 | /** |
||
575 | * Function signature corresponding to this function prototype instance |
||
576 | * |
||
577 | * Used by ast_function_definition::hir to process the parameters, etc. |
||
578 | * of the function. |
||
579 | * |
||
580 | * \sa ::hir |
||
581 | */ |
||
582 | class ir_function_signature *signature; |
||
583 | |||
584 | friend class ast_function_definition; |
||
585 | }; |
||
586 | |||
587 | |||
588 | class ast_declaration_statement : public ast_node { |
||
589 | public: |
||
590 | ast_declaration_statement(void); |
||
591 | |||
592 | enum { |
||
593 | ast_function, |
||
594 | ast_declaration, |
||
595 | ast_precision |
||
596 | } mode; |
||
597 | |||
598 | union { |
||
599 | class ast_function *function; |
||
600 | ast_declarator_list *declarator; |
||
601 | ast_type_specifier *type; |
||
602 | ast_node *node; |
||
603 | } declaration; |
||
604 | }; |
||
605 | |||
606 | |||
607 | class ast_expression_statement : public ast_node { |
||
608 | public: |
||
609 | ast_expression_statement(ast_expression *); |
||
610 | virtual void print(void) const; |
||
611 | |||
612 | virtual ir_rvalue *hir(exec_list *instructions, |
||
613 | struct _mesa_glsl_parse_state *state); |
||
614 | |||
615 | ast_expression *expression; |
||
616 | }; |
||
617 | |||
618 | |||
619 | class ast_case_label : public ast_node { |
||
620 | public: |
||
621 | |||
622 | /** |
||
623 | * An expression of NULL means 'default'. |
||
624 | */ |
||
625 | ast_expression *expression; |
||
626 | }; |
||
627 | |||
628 | class ast_selection_statement : public ast_node { |
||
629 | public: |
||
630 | ast_selection_statement(ast_expression *condition, |
||
631 | ast_node *then_statement, |
||
632 | ast_node *else_statement); |
||
633 | virtual void print(void) const; |
||
634 | |||
635 | virtual ir_rvalue *hir(exec_list *instructions, |
||
636 | struct _mesa_glsl_parse_state *state); |
||
637 | |||
638 | ast_expression *condition; |
||
639 | ast_node *then_statement; |
||
640 | ast_node *else_statement; |
||
641 | }; |
||
642 | |||
643 | |||
644 | class ast_switch_statement : public ast_node { |
||
645 | public: |
||
646 | ast_expression *expression; |
||
647 | exec_list statements; |
||
648 | }; |
||
649 | |||
650 | class ast_iteration_statement : public ast_node { |
||
651 | public: |
||
652 | ast_iteration_statement(int mode, ast_node *init, ast_node *condition, |
||
653 | ast_expression *rest_expression, ast_node *body); |
||
654 | |||
655 | virtual void print(void) const; |
||
656 | |||
657 | virtual ir_rvalue *hir(exec_list *, struct _mesa_glsl_parse_state *); |
||
658 | |||
659 | enum ast_iteration_modes { |
||
660 | ast_for, |
||
661 | ast_while, |
||
662 | ast_do_while |
||
663 | } mode; |
||
664 | |||
665 | |||
666 | ast_node *init_statement; |
||
667 | ast_node *condition; |
||
668 | ast_expression *rest_expression; |
||
669 | |||
670 | ast_node *body; |
||
671 | |||
672 | private: |
||
673 | /** |
||
674 | * Generate IR from the condition of a loop |
||
675 | * |
||
676 | * This is factored out of ::hir because some loops have the condition |
||
677 | * test at the top (for and while), and others have it at the end (do-while). |
||
678 | */ |
||
679 | void condition_to_hir(class ir_loop *, struct _mesa_glsl_parse_state *); |
||
680 | }; |
||
681 | |||
682 | |||
683 | class ast_jump_statement : public ast_node { |
||
684 | public: |
||
685 | ast_jump_statement(int mode, ast_expression *return_value); |
||
686 | virtual void print(void) const; |
||
687 | |||
688 | virtual ir_rvalue *hir(exec_list *instructions, |
||
689 | struct _mesa_glsl_parse_state *state); |
||
690 | |||
691 | enum ast_jump_modes { |
||
692 | ast_continue, |
||
693 | ast_break, |
||
694 | ast_return, |
||
695 | ast_discard |
||
696 | } mode; |
||
697 | |||
698 | ast_expression *opt_return_value; |
||
699 | }; |
||
700 | |||
701 | |||
702 | class ast_function_definition : public ast_node { |
||
703 | public: |
||
704 | virtual void print(void) const; |
||
705 | |||
706 | virtual ir_rvalue *hir(exec_list *instructions, |
||
707 | struct _mesa_glsl_parse_state *state); |
||
708 | |||
709 | ast_function *prototype; |
||
710 | ast_compound_statement *body; |
||
711 | }; |
||
712 | /*@}*/ |
||
713 | |||
714 | extern void |
||
715 | _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state); |
||
716 | |||
717 | extern ir_rvalue * |
||
718 | _mesa_ast_field_selection_to_hir(const ast_expression *expr, |
||
719 | exec_list *instructions, |
||
720 | struct _mesa_glsl_parse_state *state); |
||
721 | |||
722 | void |
||
723 | emit_function(_mesa_glsl_parse_state *state, exec_list *instructions, |
||
724 | ir_function *f); |
||
725 | |||
726 | #endif /* AST_H */>>>>> |