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_SAMPLER_1D
:
125 case SLANG_SPEC_SAMPLER_2D
:
128 case SLANG_SPEC_SAMPLER_3D
:
131 case SLANG_SPEC_SAMPLER_CUBE
:
132 printf("samplerCube");
134 case SLANG_SPEC_SAMPLER_1D_SHADOW
:
135 printf("sampler1DShadow");
137 case SLANG_SPEC_SAMPLER_2D_SHADOW
:
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
:
264 case SLANG_OPER_NON_INLINED_CALL
:
266 printf("{{ // new scope locals=%p outer=%p: ",
268 (void *) op
->locals
->outer_scope
);
269 for (i
= 0; i
< op
->locals
->num_variables
; i
++) {
270 printf("%s ", (char *) op
->locals
->variables
[i
]->a_name
);
273 print_generic(op
, NULL
, indent
+3);
278 case SLANG_OPER_VARIABLE_DECL
:
279 assert(op
->num_children
== 0 || op
->num_children
== 1);
282 v
= _slang_variable_locate(op
->locals
, op
->a_id
, GL_TRUE
);
284 const slang_variable_scope
*scope
;
286 printf("DECL (locals=%p outer=%p) ", (void*)op
->locals
, (void*) op
->locals
->outer_scope
);
287 print_type(&v
->type
);
288 printf(" %s (%p)", (char *) op
->a_id
,
289 (void *) find_var(op
->locals
, op
->a_id
));
291 scope
= find_scope(op
->locals
, op
->a_id
);
292 printf(" (in scope %p) ", (void *) scope
);
294 if (op
->num_children
== 1) {
296 slang_print_tree(&op
->children
[0], indent
+ 3);
298 else if (v
->initializer
) {
299 printf(" := INITIALIZER\n");
300 slang_print_tree(v
->initializer
, indent
+ 3);
308 print_type(&v->type);
310 printf("ADDR: %d size: %d\n", v->address, v->size);
315 printf("DECL %s (anonymous variable!!!!)\n", (char *) op
->a_id
);
322 printf("ASM: %s at %p locals=%p outer=%p\n",
326 (void *) op
->locals
->outer_scope
);
327 print_generic(op
, "ASM", indent
+3);
330 case SLANG_OPER_BREAK
:
335 case SLANG_OPER_CONTINUE
:
337 printf("CONTINUE\n");
340 case SLANG_OPER_DISCARD
:
345 case SLANG_OPER_RETURN
:
348 if (op
->num_children
> 0)
349 slang_print_tree(&op
->children
[0], indent
+ 3);
352 case SLANG_OPER_RETURN_INLINED
:
354 printf("RETURN_INLINED\n");
355 if (op
->num_children
> 0)
356 slang_print_tree(&op
->children
[0], indent
+ 3);
359 case SLANG_OPER_LABEL
:
361 printf("LABEL %s\n", (char *) op
->a_id
);
364 case SLANG_OPER_EXPRESSION
:
366 printf("EXPR: locals=%p outer=%p\n",
368 (void *) op
->locals
->outer_scope
);
369 /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
370 slang_print_tree(&op
->children
[0], indent
+ 3);
376 slang_print_tree(&op
->children
[0], indent
+ 3);
379 slang_print_tree(&op
->children
[1], indent
+ 3);
382 slang_print_tree(&op
->children
[2], indent
+ 3);
387 case SLANG_OPER_WHILE
:
388 assert(op
->num_children
== 2);
390 printf("WHILE LOOP: locals = %p\n", (void *) op
->locals
);
393 printf("WHILE cond:\n");
394 slang_print_tree(&op
->children
[0], indent
+ 3);
396 printf("WHILE body:\n");
397 slang_print_tree(&op
->children
[1], indent
+ 3);
400 printf("END WHILE LOOP\n");
405 printf("DO LOOP: locals = %p\n", (void *) op
->locals
);
408 printf("DO body:\n");
409 slang_print_tree(&op
->children
[0], indent
+ 3);
411 printf("DO cond:\n");
412 slang_print_tree(&op
->children
[1], indent
+ 3);
415 printf("END DO LOOP\n");
420 printf("FOR LOOP: locals = %p\n", (void *) op
->locals
);
423 printf("FOR init:\n");
424 slang_print_tree(&op
->children
[0], indent
+ 3);
426 printf("FOR condition:\n");
427 slang_print_tree(&op
->children
[1], indent
+ 3);
429 printf("FOR step:\n");
430 slang_print_tree(&op
->children
[2], indent
+ 3);
432 printf("FOR body:\n");
433 slang_print_tree(&op
->children
[3], indent
+ 3);
438 print_generic(op, "FOR", indent + 3);
442 case SLANG_OPER_VOID
:
444 printf("(oper-void)\n");
447 case SLANG_OPER_LITERAL_BOOL
:
450 for (i
= 0; i
< op
->literal_size
; i
++)
451 printf("%s ", op
->literal
[0] ? "TRUE" : "FALSE");
456 case SLANG_OPER_LITERAL_INT
:
459 for (i
= 0; i
< op
->literal_size
; i
++)
460 printf("%d ", (int) op
->literal
[i
]);
464 case SLANG_OPER_LITERAL_FLOAT
:
467 for (i
= 0; i
< op
->literal_size
; i
++)
468 printf("%f ", op
->literal
[i
]);
472 case SLANG_OPER_IDENTIFIER
:
474 const slang_variable_scope
*scope
;
476 if (op
->var
&& op
->var
->a_name
) {
477 scope
= find_scope(op
->locals
, op
->var
->a_name
);
478 printf("VAR %s (in scope %p)\n", (char *) op
->var
->a_name
,
483 scope
= find_scope(op
->locals
, op
->a_id
);
484 printf("VAR' %s (in scope %p) locals=%p outer=%p\n",
488 (void *) op
->locals
->outer_scope
);
494 case SLANG_OPER_SEQUENCE
:
495 print_generic(op
, "COMMA-SEQ", indent
+3);
498 case SLANG_OPER_ASSIGN
:
500 printf("ASSIGNMENT locals=%p outer=%p\n",
502 (void *) op
->locals
->outer_scope
);
503 print_binary(op
, ":=", indent
);
506 case SLANG_OPER_ADDASSIGN
:
509 print_binary(op
, "+=", indent
);
512 case SLANG_OPER_SUBASSIGN
:
515 print_binary(op
, "-=", indent
);
518 case SLANG_OPER_MULASSIGN
:
521 print_binary(op
, "*=", indent
);
524 case SLANG_OPER_DIVASSIGN
:
527 print_binary(op
, "/=", indent
);
530 /*SLANG_OPER_MODASSIGN,*/
531 /*SLANG_OPER_LSHASSIGN,*/
532 /*SLANG_OPER_RSHASSIGN,*/
533 /*SLANG_OPER_ORASSIGN,*/
534 /*SLANG_OPER_XORASSIGN,*/
535 /*SLANG_OPER_ANDASSIGN,*/
536 case SLANG_OPER_SELECT
:
538 printf("SLANG_OPER_SELECT n=%d\n", op
->num_children
);
539 assert(op
->num_children
== 3);
540 slang_print_tree(&op
->children
[0], indent
+3);
543 slang_print_tree(&op
->children
[1], indent
+3);
546 slang_print_tree(&op
->children
[2], indent
+3);
549 case SLANG_OPER_LOGICALOR
:
550 print_binary(op
, "||", indent
);
553 case SLANG_OPER_LOGICALXOR
:
554 print_binary(op
, "^^", indent
);
557 case SLANG_OPER_LOGICALAND
:
558 print_binary(op
, "&&", indent
);
562 /*SLANG_OPER_BITXOR*/
563 /*SLANG_OPER_BITAND*/
564 case SLANG_OPER_EQUAL
:
565 print_binary(op
, "==", indent
);
568 case SLANG_OPER_NOTEQUAL
:
569 print_binary(op
, "!=", indent
);
572 case SLANG_OPER_LESS
:
573 print_binary(op
, "<", indent
);
576 case SLANG_OPER_GREATER
:
577 print_binary(op
, ">", indent
);
580 case SLANG_OPER_LESSEQUAL
:
581 print_binary(op
, "<=", indent
);
584 case SLANG_OPER_GREATEREQUAL
:
585 print_binary(op
, ">=", indent
);
588 /*SLANG_OPER_LSHIFT*/
589 /*SLANG_OPER_RSHIFT*/
591 print_binary(op
, "+", indent
);
594 case SLANG_OPER_SUBTRACT
:
595 print_binary(op
, "-", indent
);
598 case SLANG_OPER_MULTIPLY
:
599 print_binary(op
, "*", indent
);
602 case SLANG_OPER_DIVIDE
:
603 print_binary(op
, "/", indent
);
606 /*SLANG_OPER_MODULUS*/
607 case SLANG_OPER_PREINCREMENT
:
610 slang_print_tree(&op
->children
[0], indent
+3);
613 case SLANG_OPER_PREDECREMENT
:
616 slang_print_tree(&op
->children
[0], indent
+3);
619 case SLANG_OPER_PLUS
:
621 printf("SLANG_OPER_PLUS\n");
624 case SLANG_OPER_MINUS
:
626 printf("SLANG_OPER_MINUS\n");
629 /*SLANG_OPER_COMPLEMENT*/
633 slang_print_tree(&op
->children
[0], indent
+3);
636 case SLANG_OPER_SUBSCRIPT
:
638 printf("SLANG_OPER_SUBSCRIPT locals=%p outer=%p\n",
640 (void *) op
->locals
->outer_scope
);
641 print_generic(op
, NULL
, indent
+3);
644 case SLANG_OPER_CALL
:
647 = _slang_function_locate(A
->space
.funcs
, oper
->a_id
,
649 oper
->num_children
, &A
->space
, A
->atoms
);
652 printf("CALL %s(\n", (char *) op
->a_id
);
653 for (i
= 0; i
< op
->num_children
; i
++) {
654 slang_print_tree(&op
->children
[i
], indent
+3);
655 if (i
+ 1 < op
->num_children
) {
664 case SLANG_OPER_METHOD
:
666 printf("METHOD CALL %s.%s\n", (char *) op
->a_obj
, (char *) op
->a_id
);
669 case SLANG_OPER_FIELD
:
671 printf("FIELD %s of\n", (char*) op
->a_id
);
672 slang_print_tree(&op
->children
[0], indent
+3);
675 case SLANG_OPER_POSTINCREMENT
:
678 slang_print_tree(&op
->children
[0], indent
+3);
681 case SLANG_OPER_POSTDECREMENT
:
684 slang_print_tree(&op
->children
[0], indent
+3);
688 printf("unknown op->type %d\n", (int) op
->type
);
696 slang_print_function(const slang_function
*f
, GLboolean body
)
701 if (strcmp((char *) f
->header
.a_name
, "main") != 0)
705 printf("FUNCTION %s ( scope=%p\n",
706 (char *) f
->header
.a_name
, (void *) f
->parameters
);
708 for (i
= 0; i
< f
->param_count
; i
++) {
709 print_variable(f
->parameters
->variables
[i
], 3);
712 printf(") param scope = %p\n", (void *) f
->parameters
);
715 slang_print_tree(f
->body
, 0);
723 slang_type_qual_string(slang_type_qualifier q
)
726 case SLANG_QUAL_NONE
:
728 case SLANG_QUAL_CONST
:
730 case SLANG_QUAL_ATTRIBUTE
:
732 case SLANG_QUAL_VARYING
:
734 case SLANG_QUAL_UNIFORM
:
738 case SLANG_QUAL_INOUT
:
740 case SLANG_QUAL_FIXEDOUTPUT
:
741 return "fixedoutput";
742 case SLANG_QUAL_FIXEDINPUT
:
743 return "fixedinputk";
751 slang_type_string(slang_type_specifier_type t
)
754 case SLANG_SPEC_VOID
:
756 case SLANG_SPEC_BOOL
:
758 case SLANG_SPEC_BVEC2
:
760 case SLANG_SPEC_BVEC3
:
762 case SLANG_SPEC_BVEC4
:
766 case SLANG_SPEC_IVEC2
:
768 case SLANG_SPEC_IVEC3
:
770 case SLANG_SPEC_IVEC4
:
772 case SLANG_SPEC_FLOAT
:
774 case SLANG_SPEC_VEC2
:
776 case SLANG_SPEC_VEC3
:
778 case SLANG_SPEC_VEC4
:
780 case SLANG_SPEC_MAT2
:
782 case SLANG_SPEC_MAT3
:
784 case SLANG_SPEC_MAT4
:
786 case SLANG_SPEC_SAMPLER_1D
:
788 case SLANG_SPEC_SAMPLER_2D
:
790 case SLANG_SPEC_SAMPLER_3D
:
792 case SLANG_SPEC_SAMPLER_CUBE
:
793 return "samplerCube";
794 case SLANG_SPEC_SAMPLER_1D_SHADOW
:
795 return "sampler1DShadow";
796 case SLANG_SPEC_SAMPLER_2D_SHADOW
:
797 return "sampler2DShadow";
798 case SLANG_SPEC_SAMPLER_RECT
:
799 return "sampler2DRect";
800 case SLANG_SPEC_SAMPLER_RECT_SHADOW
:
801 return "sampler2DRectShadow";
802 case SLANG_SPEC_STRUCT
:
804 case SLANG_SPEC_ARRAY
:
813 slang_fq_type_string(const slang_fully_specified_type
*t
)
815 static char str
[1000];
816 _mesa_snprintf(str
, sizeof(str
), "%s %s", slang_type_qual_string(t
->qualifier
),
817 slang_type_string(t
->specifier
.type
));
823 slang_print_type(const slang_fully_specified_type
*t
)
825 printf("%s %s", slang_type_qual_string(t
->qualifier
),
826 slang_type_string(t
->specifier
.type
));
832 slang_var_string(const slang_variable
*v
)
834 static char str
[1000];
835 _mesa_snprintf(str
, sizeof(str
), "%s : %s",
837 slang_fq_type_string(&v
->type
));
844 slang_print_variable(const slang_variable
*v
)
846 printf("Name: %s\n", (char *) v
->a_name
);
847 printf("Type: %s\n", slang_fq_type_string(&v
->type
));
852 _slang_print_var_scope(const slang_variable_scope
*vars
, int indent
)
857 printf("Var scope %p %d vars:\n", (void *) vars
, vars
->num_variables
);
858 for (i
= 0; i
< vars
->num_variables
; i
++) {
860 printf("%s (at %p)\n", (char *) vars
->variables
[i
]->a_name
, (void*) (vars
->variables
+ i
));
863 printf("outer_scope = %p\n", (void*) vars
->outer_scope
);
865 if (vars
->outer_scope
) {
866 /*spaces(indent + 3);*/
867 _slang_print_var_scope(vars
->outer_scope
, indent
+ 3);
874 slang_checksum_tree(const slang_operation
*op
)
876 int s
= op
->num_children
;
879 for (i
= 0; i
< op
->num_children
; i
++) {
880 s
+= slang_checksum_tree(&op
->children
[i
]);