3 * Dump/print a slang_operation tree
7 #include "main/imports.h"
8 #include "slang_compile.h"
9 #include "slang_print.h"
21 print_type(const slang_fully_specified_type
*t
)
23 switch (t
->qualifier
) {
27 case SLANG_QUAL_CONST
:
30 case SLANG_QUAL_ATTRIBUTE
:
33 case SLANG_QUAL_VARYING
:
36 case SLANG_QUAL_UNIFORM
:
42 case SLANG_QUAL_INOUT
:
45 case SLANG_QUAL_FIXEDOUTPUT
:
46 printf("fixedoutput");
48 case SLANG_QUAL_FIXEDINPUT
:
52 printf("unknown qualifer!");
55 switch (t
->specifier
.type
) {
62 case SLANG_SPEC_BVEC2
:
65 case SLANG_SPEC_BVEC3
:
68 case SLANG_SPEC_BVEC4
:
74 case SLANG_SPEC_IVEC2
:
77 case SLANG_SPEC_IVEC3
:
80 case SLANG_SPEC_IVEC4
:
83 case SLANG_SPEC_FLOAT
:
101 case SLANG_SPEC_MAT4
:
104 case SLANG_SPEC_MAT23
:
107 case SLANG_SPEC_MAT32
:
110 case SLANG_SPEC_MAT24
:
113 case SLANG_SPEC_MAT42
:
116 case SLANG_SPEC_MAT34
:
119 case SLANG_SPEC_MAT43
:
122 case SLANG_SPEC_SAMPLER1D
:
125 case SLANG_SPEC_SAMPLER2D
:
128 case SLANG_SPEC_SAMPLER3D
:
131 case SLANG_SPEC_SAMPLERCUBE
:
132 printf("samplerCube");
134 case SLANG_SPEC_SAMPLER1DSHADOW
:
135 printf("sampler1DShadow");
137 case SLANG_SPEC_SAMPLER2DSHADOW
:
138 printf("sampler2DShadow");
140 case SLANG_SPEC_STRUCT
:
143 case SLANG_SPEC_ARRAY
:
147 printf("unknown type");
154 print_variable(const slang_variable
*v
, int indent
)
158 print_type(&v
->type
);
159 printf(" %s (at %p)", (char *) v
->a_name
, (void *) v
);
160 if (v
->initializer
) {
162 slang_print_tree(v
->initializer
, indent
+ 3);
171 print_binary(const slang_operation
*op
, const char *oper
, int indent
)
173 assert(op
->num_children
== 2);
175 printf("binary at %p locals=%p outer=%p\n",
178 (void *) op
->locals
->outer_scope
);
180 slang_print_tree(&op
->children
[0], indent
+ 3);
182 printf("%s at %p locals=%p outer=%p\n",
183 oper
, (void *) op
, (void *) op
->locals
,
184 (void *) op
->locals
->outer_scope
);
185 slang_print_tree(&op
->children
[1], indent
+ 3);
190 print_generic2(const slang_operation
*op
, const char *oper
,
191 const char *s
, int indent
)
196 printf("%s %s at %p locals=%p outer=%p\n",
197 oper
, s
, (void *) op
, (void *) op
->locals
,
198 (void *) op
->locals
->outer_scope
);
200 for (i
= 0; i
< op
->num_children
; i
++) {
202 printf("//child %u of %u:\n", i
, op
->num_children
);
203 slang_print_tree(&op
->children
[i
], indent
);
208 print_generic(const slang_operation
*op
, const char *oper
, int indent
)
210 print_generic2(op
, oper
, "", indent
);
214 static const slang_variable_scope
*
215 find_scope(const slang_variable_scope
*s
, slang_atom name
)
218 for (i
= 0; i
< s
->num_variables
; i
++) {
219 if (s
->variables
[i
]->a_name
== name
)
223 return find_scope(s
->outer_scope
, name
);
228 static const slang_variable
*
229 find_var(const slang_variable_scope
*s
, slang_atom name
)
232 for (i
= 0; i
< s
->num_variables
; i
++) {
233 if (s
->variables
[i
]->a_name
== name
)
234 return s
->variables
[i
];
237 return find_var(s
->outer_scope
, name
);
244 slang_print_tree(const slang_operation
*op
, int indent
)
250 case SLANG_OPER_NONE
:
252 printf("SLANG_OPER_NONE\n");
255 case SLANG_OPER_BLOCK_NO_NEW_SCOPE
:
257 printf("{ locals=%p outer=%p\n", (void*)op
->locals
, (void*)op
->locals
->outer_scope
);
258 print_generic(op
, NULL
, indent
+3);
263 case SLANG_OPER_BLOCK_NEW_SCOPE
:
265 printf("{{ // new scope locals=%p outer=%p: ",
267 (void *) op
->locals
->outer_scope
);
268 for (i
= 0; i
< op
->locals
->num_variables
; i
++) {
269 printf("%s ", (char *) op
->locals
->variables
[i
]->a_name
);
272 print_generic(op
, NULL
, indent
+3);
277 case SLANG_OPER_VARIABLE_DECL
:
278 assert(op
->num_children
== 0 || op
->num_children
== 1);
281 v
= _slang_locate_variable(op
->locals
, op
->a_id
, GL_TRUE
);
283 const slang_variable_scope
*scope
;
285 printf("DECL (locals=%p outer=%p) ", (void*)op
->locals
, (void*) op
->locals
->outer_scope
);
286 print_type(&v
->type
);
287 printf(" %s (%p)", (char *) op
->a_id
,
288 (void *) find_var(op
->locals
, op
->a_id
));
290 scope
= find_scope(op
->locals
, op
->a_id
);
291 printf(" (in scope %p) ", (void *) scope
);
293 if (op
->num_children
== 1) {
295 slang_print_tree(&op
->children
[0], indent
+ 3);
297 else if (v
->initializer
) {
298 printf(" := INITIALIZER\n");
299 slang_print_tree(v
->initializer
, indent
+ 3);
307 print_type(&v->type);
309 printf("ADDR: %d size: %d\n", v->address, v->size);
314 printf("DECL %s (anonymous variable!!!!)\n", (char *) op
->a_id
);
321 printf("ASM: %s at %p locals=%p outer=%p\n",
325 (void *) op
->locals
->outer_scope
);
326 print_generic(op
, "ASM", indent
+3);
329 case SLANG_OPER_BREAK
:
334 case SLANG_OPER_CONTINUE
:
336 printf("CONTINUE\n");
339 case SLANG_OPER_DISCARD
:
344 case SLANG_OPER_RETURN
:
347 if (op
->num_children
> 0)
348 slang_print_tree(&op
->children
[0], indent
+ 3);
351 case SLANG_OPER_LABEL
:
353 printf("LABEL %s\n", (char *) op
->a_id
);
356 case SLANG_OPER_EXPRESSION
:
358 printf("EXPR: locals=%p outer=%p\n",
360 (void *) op
->locals
->outer_scope
);
361 /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
362 slang_print_tree(&op
->children
[0], indent
+ 3);
368 slang_print_tree(&op
->children
[0], indent
+ 3);
371 slang_print_tree(&op
->children
[1], indent
+ 3);
374 slang_print_tree(&op
->children
[2], indent
+ 3);
379 case SLANG_OPER_WHILE
:
380 assert(op
->num_children
== 2);
382 printf("WHILE cond:\n");
383 slang_print_tree(&op
->children
[0], indent
+ 3);
385 printf("WHILE body:\n");
386 slang_print_tree(&op
->children
[1], indent
+ 3);
391 printf("DO body:\n");
392 slang_print_tree(&op
->children
[0], indent
+ 3);
394 printf("DO cond:\n");
395 slang_print_tree(&op
->children
[1], indent
+ 3);
400 printf("FOR init:\n");
401 slang_print_tree(&op
->children
[0], indent
+ 3);
403 printf("FOR while:\n");
404 slang_print_tree(&op
->children
[1], indent
+ 3);
406 printf("FOR step:\n");
407 slang_print_tree(&op
->children
[2], indent
+ 3);
409 printf("FOR body:\n");
410 slang_print_tree(&op
->children
[3], indent
+ 3);
414 print_generic(op, "FOR", indent + 3);
418 case SLANG_OPER_VOID
:
420 printf("(oper-void)\n");
423 case SLANG_OPER_LITERAL_BOOL
:
426 for (i
= 0; i
< op
->literal_size
; i
++)
427 printf("%s ", op
->literal
[0] ? "TRUE" : "FALSE");
432 case SLANG_OPER_LITERAL_INT
:
435 for (i
= 0; i
< op
->literal_size
; i
++)
436 printf("%d ", (int) op
->literal
[i
]);
440 case SLANG_OPER_LITERAL_FLOAT
:
443 for (i
= 0; i
< op
->literal_size
; i
++)
444 printf("%f ", op
->literal
[i
]);
448 case SLANG_OPER_IDENTIFIER
:
450 const slang_variable_scope
*scope
;
452 if (op
->var
&& op
->var
->a_name
) {
453 scope
= find_scope(op
->locals
, op
->var
->a_name
);
454 printf("VAR %s (in scope %p)\n", (char *) op
->var
->a_name
,
459 scope
= find_scope(op
->locals
, op
->a_id
);
460 printf("VAR' %s (in scope %p) locals=%p outer=%p\n",
464 (void *) op
->locals
->outer_scope
);
470 case SLANG_OPER_SEQUENCE
:
471 print_generic(op
, "COMMA-SEQ", indent
+3);
474 case SLANG_OPER_ASSIGN
:
476 printf("ASSIGNMENT locals=%p outer=%p\n",
478 (void *) op
->locals
->outer_scope
);
479 print_binary(op
, ":=", indent
);
482 case SLANG_OPER_ADDASSIGN
:
485 print_binary(op
, "+=", indent
);
488 case SLANG_OPER_SUBASSIGN
:
491 print_binary(op
, "-=", indent
);
494 case SLANG_OPER_MULASSIGN
:
497 print_binary(op
, "*=", indent
);
500 case SLANG_OPER_DIVASSIGN
:
503 print_binary(op
, "/=", indent
);
506 /*SLANG_OPER_MODASSIGN,*/
507 /*SLANG_OPER_LSHASSIGN,*/
508 /*SLANG_OPER_RSHASSIGN,*/
509 /*SLANG_OPER_ORASSIGN,*/
510 /*SLANG_OPER_XORASSIGN,*/
511 /*SLANG_OPER_ANDASSIGN,*/
512 case SLANG_OPER_SELECT
:
514 printf("SLANG_OPER_SELECT n=%d\n", op
->num_children
);
515 assert(op
->num_children
== 3);
516 slang_print_tree(&op
->children
[0], indent
+3);
519 slang_print_tree(&op
->children
[1], indent
+3);
522 slang_print_tree(&op
->children
[2], indent
+3);
525 case SLANG_OPER_LOGICALOR
:
526 print_binary(op
, "||", indent
);
529 case SLANG_OPER_LOGICALXOR
:
530 print_binary(op
, "^^", indent
);
533 case SLANG_OPER_LOGICALAND
:
534 print_binary(op
, "&&", indent
);
538 /*SLANG_OPER_BITXOR*/
539 /*SLANG_OPER_BITAND*/
540 case SLANG_OPER_EQUAL
:
541 print_binary(op
, "==", indent
);
544 case SLANG_OPER_NOTEQUAL
:
545 print_binary(op
, "!=", indent
);
548 case SLANG_OPER_LESS
:
549 print_binary(op
, "<", indent
);
552 case SLANG_OPER_GREATER
:
553 print_binary(op
, ">", indent
);
556 case SLANG_OPER_LESSEQUAL
:
557 print_binary(op
, "<=", indent
);
560 case SLANG_OPER_GREATEREQUAL
:
561 print_binary(op
, ">=", indent
);
564 /*SLANG_OPER_LSHIFT*/
565 /*SLANG_OPER_RSHIFT*/
567 print_binary(op
, "+", indent
);
570 case SLANG_OPER_SUBTRACT
:
571 print_binary(op
, "-", indent
);
574 case SLANG_OPER_MULTIPLY
:
575 print_binary(op
, "*", indent
);
578 case SLANG_OPER_DIVIDE
:
579 print_binary(op
, "/", indent
);
582 /*SLANG_OPER_MODULUS*/
583 case SLANG_OPER_PREINCREMENT
:
586 slang_print_tree(&op
->children
[0], indent
+3);
589 case SLANG_OPER_PREDECREMENT
:
592 slang_print_tree(&op
->children
[0], indent
+3);
595 case SLANG_OPER_PLUS
:
597 printf("SLANG_OPER_PLUS\n");
600 case SLANG_OPER_MINUS
:
602 printf("SLANG_OPER_MINUS\n");
605 /*SLANG_OPER_COMPLEMENT*/
609 slang_print_tree(&op
->children
[0], indent
+3);
612 case SLANG_OPER_SUBSCRIPT
:
614 printf("SLANG_OPER_SUBSCRIPT locals=%p outer=%p\n",
616 (void *) op
->locals
->outer_scope
);
617 print_generic(op
, NULL
, indent
+3);
620 case SLANG_OPER_CALL
:
623 = _slang_locate_function(A
->space
.funcs
, oper
->a_id
,
625 oper
->num_children
, &A
->space
, A
->atoms
);
628 printf("CALL %s(\n", (char *) op
->a_id
);
629 for (i
= 0; i
< op
->num_children
; i
++) {
630 slang_print_tree(&op
->children
[i
], indent
+3);
631 if (i
+ 1 < op
->num_children
) {
640 case SLANG_OPER_FIELD
:
642 printf("FIELD %s of\n", (char*) op
->a_id
);
643 slang_print_tree(&op
->children
[0], indent
+3);
646 case SLANG_OPER_POSTINCREMENT
:
649 slang_print_tree(&op
->children
[0], indent
+3);
652 case SLANG_OPER_POSTDECREMENT
:
655 slang_print_tree(&op
->children
[0], indent
+3);
659 printf("unknown op->type %d\n", (int) op
->type
);
667 slang_print_function(const slang_function
*f
, GLboolean body
)
672 if (_mesa_strcmp((char *) f
->header
.a_name
, "main") != 0)
676 printf("FUNCTION %s ( scope=%p\n",
677 (char *) f
->header
.a_name
, (void *) f
->parameters
);
679 for (i
= 0; i
< f
->param_count
; i
++) {
680 print_variable(f
->parameters
->variables
[i
], 3);
683 printf(") param scope = %p\n", (void *) f
->parameters
);
686 slang_print_tree(f
->body
, 0);
694 slang_type_qual_string(slang_type_qualifier q
)
697 case SLANG_QUAL_NONE
:
699 case SLANG_QUAL_CONST
:
701 case SLANG_QUAL_ATTRIBUTE
:
703 case SLANG_QUAL_VARYING
:
705 case SLANG_QUAL_UNIFORM
:
709 case SLANG_QUAL_INOUT
:
711 case SLANG_QUAL_FIXEDOUTPUT
:
712 return "fixedoutput";
713 case SLANG_QUAL_FIXEDINPUT
:
714 return "fixedinputk";
722 slang_type_string(slang_type_specifier_type t
)
725 case SLANG_SPEC_VOID
:
727 case SLANG_SPEC_BOOL
:
729 case SLANG_SPEC_BVEC2
:
731 case SLANG_SPEC_BVEC3
:
733 case SLANG_SPEC_BVEC4
:
737 case SLANG_SPEC_IVEC2
:
739 case SLANG_SPEC_IVEC3
:
741 case SLANG_SPEC_IVEC4
:
743 case SLANG_SPEC_FLOAT
:
745 case SLANG_SPEC_VEC2
:
747 case SLANG_SPEC_VEC3
:
749 case SLANG_SPEC_VEC4
:
751 case SLANG_SPEC_MAT2
:
753 case SLANG_SPEC_MAT3
:
755 case SLANG_SPEC_MAT4
:
757 case SLANG_SPEC_SAMPLER1D
:
759 case SLANG_SPEC_SAMPLER2D
:
761 case SLANG_SPEC_SAMPLER3D
:
763 case SLANG_SPEC_SAMPLERCUBE
:
764 return "samplerCube";
765 case SLANG_SPEC_SAMPLER1DSHADOW
:
766 return "sampler1DShadow";
767 case SLANG_SPEC_SAMPLER2DSHADOW
:
768 return "sampler2DShadow";
769 case SLANG_SPEC_SAMPLER2DRECT
:
770 return "sampler2DRect";
771 case SLANG_SPEC_SAMPLER2DRECTSHADOW
:
772 return "sampler2DRectShadow";
773 case SLANG_SPEC_STRUCT
:
775 case SLANG_SPEC_ARRAY
:
784 slang_fq_type_string(const slang_fully_specified_type
*t
)
786 static char str
[1000];
787 sprintf(str
, "%s %s", slang_type_qual_string(t
->qualifier
),
788 slang_type_string(t
->specifier
.type
));
794 slang_print_type(const slang_fully_specified_type
*t
)
796 printf("%s %s", slang_type_qual_string(t
->qualifier
),
797 slang_type_string(t
->specifier
.type
));
803 slang_var_string(const slang_variable
*v
)
805 static char str
[1000];
806 sprintf(str
, "%s : %s",
808 slang_fq_type_string(&v
->type
));
815 slang_print_variable(const slang_variable
*v
)
817 printf("Name: %s\n", (char *) v
->a_name
);
818 printf("Type: %s\n", slang_fq_type_string(&v
->type
));
823 _slang_print_var_scope(const slang_variable_scope
*vars
, int indent
)
828 printf("Var scope %p %d vars:\n", (void *) vars
, vars
->num_variables
);
829 for (i
= 0; i
< vars
->num_variables
; i
++) {
831 printf("%s (at %p)\n", (char *) vars
->variables
[i
]->a_name
, (void*) (vars
->variables
+ i
));
834 printf("outer_scope = %p\n", (void*) vars
->outer_scope
);
836 if (vars
->outer_scope
) {
837 /*spaces(indent + 3);*/
838 _slang_print_var_scope(vars
->outer_scope
, indent
+ 3);
845 slang_checksum_tree(const slang_operation
*op
)
847 int s
= op
->num_children
;
850 for (i
= 0; i
< op
->num_children
; i
++) {
851 s
+= slang_checksum_tree(&op
->children
[i
]);