*/
-#include "imports.h"
+#include "main/imports.h"
#include "slang_compile.h"
#include "slang_print.h"
print_type(const slang_fully_specified_type *t)
{
switch (t->qualifier) {
- case slang_qual_none:
+ case SLANG_QUAL_NONE:
/*printf("");*/
break;
- case slang_qual_const:
+ case SLANG_QUAL_CONST:
printf("const ");
break;
- case slang_qual_attribute:
+ case SLANG_QUAL_ATTRIBUTE:
printf("attrib ");
break;
- case slang_qual_varying:
+ case SLANG_QUAL_VARYING:
printf("varying ");
break;
- case slang_qual_uniform:
+ case SLANG_QUAL_UNIFORM:
printf("uniform ");
break;
- case slang_qual_out:
+ case SLANG_QUAL_OUT:
printf("output ");
break;
- case slang_qual_inout:
+ case SLANG_QUAL_INOUT:
printf("inout ");
break;
- case slang_qual_fixedoutput:
+ case SLANG_QUAL_FIXEDOUTPUT:
printf("fixedoutput");
break;
- case slang_qual_fixedinput:
+ case SLANG_QUAL_FIXEDINPUT:
printf("fixedinput");
break;
default:
}
switch (t->specifier.type) {
- case slang_spec_void:
+ case SLANG_SPEC_VOID:
printf("void");
break;
- case slang_spec_bool:
+ case SLANG_SPEC_BOOL:
printf("bool");
break;
- case slang_spec_bvec2:
+ case SLANG_SPEC_BVEC2:
printf("bvec2");
break;
- case slang_spec_bvec3:
+ case SLANG_SPEC_BVEC3:
printf("bvec3");
break;
- case slang_spec_bvec4:
+ case SLANG_SPEC_BVEC4:
printf("bvec4");
break;
- case slang_spec_int:
+ case SLANG_SPEC_INT:
printf("int");
break;
- case slang_spec_ivec2:
+ case SLANG_SPEC_IVEC2:
printf("ivec2");
break;
- case slang_spec_ivec3:
+ case SLANG_SPEC_IVEC3:
printf("ivec3");
break;
- case slang_spec_ivec4:
+ case SLANG_SPEC_IVEC4:
printf("ivec4");
break;
- case slang_spec_float:
+ case SLANG_SPEC_FLOAT:
printf("float");
break;
- case slang_spec_vec2:
+ case SLANG_SPEC_VEC2:
printf("vec2");
break;
- case slang_spec_vec3:
+ case SLANG_SPEC_VEC3:
printf("vec3");
break;
- case slang_spec_vec4:
+ case SLANG_SPEC_VEC4:
printf("vec4");
break;
- case slang_spec_mat2:
+ case SLANG_SPEC_MAT2:
printf("mat2");
break;
- case slang_spec_mat3:
+ case SLANG_SPEC_MAT3:
printf("mat3");
break;
- case slang_spec_mat4:
+ case SLANG_SPEC_MAT4:
printf("mat4");
break;
- case slang_spec_sampler1D:
+ case SLANG_SPEC_MAT23:
+ printf("mat2x3");
+ break;
+ case SLANG_SPEC_MAT32:
+ printf("mat3x2");
+ break;
+ case SLANG_SPEC_MAT24:
+ printf("mat2x4");
+ break;
+ case SLANG_SPEC_MAT42:
+ printf("mat4x2");
+ break;
+ case SLANG_SPEC_MAT34:
+ printf("mat3x4");
+ break;
+ case SLANG_SPEC_MAT43:
+ printf("mat4x3");
+ break;
+ case SLANG_SPEC_SAMPLER1D:
printf("sampler1D");
break;
- case slang_spec_sampler2D:
+ case SLANG_SPEC_SAMPLER2D:
printf("sampler2D");
break;
- case slang_spec_sampler3D:
+ case SLANG_SPEC_SAMPLER3D:
printf("sampler3D");
break;
- case slang_spec_samplerCube:
+ case SLANG_SPEC_SAMPLERCUBE:
printf("samplerCube");
break;
- case slang_spec_sampler1DShadow:
+ case SLANG_SPEC_SAMPLER1DSHADOW:
printf("sampler1DShadow");
break;
- case slang_spec_sampler2DShadow:
+ case SLANG_SPEC_SAMPLER2DSHADOW:
printf("sampler2DShadow");
break;
- case slang_spec_struct:
+ case SLANG_SPEC_STRUCT:
printf("struct");
break;
- case slang_spec_array:
+ case SLANG_SPEC_ARRAY:
printf("array");
break;
default:
spaces(indent);
printf("VAR ");
print_type(&v->type);
- printf(" %s", (char *) v->a_name);
+ printf(" %s (at %p)", (char *) v->a_name, (void *) v);
if (v->initializer) {
printf(" :=\n");
slang_print_tree(v->initializer, indent + 3);
print_binary(const slang_operation *op, const char *oper, int indent)
{
assert(op->num_children == 2);
+#if 0
+ printf("binary at %p locals=%p outer=%p\n",
+ (void *) op,
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
+#endif
slang_print_tree(&op->children[0], indent + 3);
spaces(indent);
- printf("%s\n", oper);
+ printf("%s at %p locals=%p outer=%p\n",
+ oper, (void *) op, (void *) op->locals,
+ (void *) op->locals->outer_scope);
slang_print_tree(&op->children[1], indent + 3);
}
print_generic2(const slang_operation *op, const char *oper,
const char *s, int indent)
{
- int i;
+ GLuint i;
if (oper) {
spaces(indent);
- printf("[%p locals %p] %s %s\n", (void*) op, (void*) op->locals, oper, s);
+ printf("%s %s at %p locals=%p outer=%p\n",
+ oper, s, (void *) op, (void *) op->locals,
+ (void *) op->locals->outer_scope);
}
for (i = 0; i < op->num_children; i++) {
spaces(indent);
- printf("//child %d:\n", i);
+ printf("//child %u of %u:\n", i, op->num_children);
slang_print_tree(&op->children[i], indent);
}
}
{
GLuint i;
for (i = 0; i < s->num_variables; i++) {
- if (s->variables[i].a_name == name)
+ if (s->variables[i]->a_name == name)
return s;
}
if (s->outer_scope)
{
GLuint i;
for (i = 0; i < s->num_variables; i++) {
- if (s->variables[i].a_name == name)
- return &s->variables[i];
+ if (s->variables[i]->a_name == name)
+ return s->variables[i];
}
if (s->outer_scope)
return find_var(s->outer_scope, name);
void
slang_print_tree(const slang_operation *op, int indent)
{
- int i;
+ GLuint i;
switch (op->type) {
- case slang_oper_none:
+ case SLANG_OPER_NONE:
spaces(indent);
- printf("slang_oper_none\n");
+ printf("SLANG_OPER_NONE\n");
break;
- case slang_oper_block_no_new_scope:
+ case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
spaces(indent);
- printf("{ locals %p outer %p\n", (void*)op->locals, (void*)op->locals->outer_scope);
+ printf("{ locals=%p outer=%p\n", (void*)op->locals, (void*)op->locals->outer_scope);
print_generic(op, NULL, indent+3);
spaces(indent);
printf("}\n");
break;
- case slang_oper_block_new_scope:
+ case SLANG_OPER_BLOCK_NEW_SCOPE:
+ case SLANG_OPER_NON_INLINED_CALL:
spaces(indent);
- printf("{{ // new scope locals %p\n", (void*)op->locals);
+ printf("{{ // new scope locals=%p outer=%p: ",
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
+ for (i = 0; i < op->locals->num_variables; i++) {
+ printf("%s ", (char *) op->locals->variables[i]->a_name);
+ }
+ printf("\n");
print_generic(op, NULL, indent+3);
spaces(indent);
printf("}}\n");
break;
- case slang_oper_variable_decl:
+ case SLANG_OPER_VARIABLE_DECL:
assert(op->num_children == 0 || op->num_children == 1);
{
slang_variable *v;
- v = _slang_locate_variable(op->locals, op->a_id, GL_TRUE);
+ v = _slang_variable_locate(op->locals, op->a_id, GL_TRUE);
if (v) {
+ const slang_variable_scope *scope;
spaces(indent);
printf("DECL (locals=%p outer=%p) ", (void*)op->locals, (void*) op->locals->outer_scope);
print_type(&v->type);
printf(" %s (%p)", (char *) op->a_id,
(void *) find_var(op->locals, op->a_id));
- printf(" (in scope %p) ",
- (void *) find_scope(op->locals, op->a_id));
+ scope = find_scope(op->locals, op->a_id);
+ printf(" (in scope %p) ", (void *) scope);
+ assert(scope);
if (op->num_children == 1) {
printf(" :=\n");
slang_print_tree(&op->children[0], indent + 3);
*/
}
else {
- abort();
spaces(indent);
printf("DECL %s (anonymous variable!!!!)\n", (char *) op->a_id);
- /*abort();*/
}
}
break;
- case slang_oper_asm:
+ case SLANG_OPER_ASM:
spaces(indent);
- printf("ASM: %s\n", (char*) op->a_id);
- print_generic(op, NULL, indent+3);
+ printf("ASM: %s at %p locals=%p outer=%p\n",
+ (char *) op->a_id,
+ (void *) op,
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
+ print_generic(op, "ASM", indent+3);
break;
- case slang_oper_break:
+ case SLANG_OPER_BREAK:
spaces(indent);
printf("BREAK\n");
break;
- case slang_oper_continue:
+ case SLANG_OPER_CONTINUE:
spaces(indent);
printf("CONTINUE\n");
break;
- case slang_oper_discard:
+ case SLANG_OPER_DISCARD:
spaces(indent);
printf("DISCARD\n");
break;
- case slang_oper_return:
+ case SLANG_OPER_RETURN:
spaces(indent);
printf("RETURN\n");
if (op->num_children > 0)
slang_print_tree(&op->children[0], indent + 3);
break;
- case slang_oper_goto:
+ case SLANG_OPER_RETURN_INLINED:
spaces(indent);
- printf("GOTO %s\n", (char *) op->a_id);
+ printf("RETURN_INLINED\n");
+ if (op->num_children > 0)
+ slang_print_tree(&op->children[0], indent + 3);
break;
- case slang_oper_label:
+ case SLANG_OPER_LABEL:
spaces(indent);
printf("LABEL %s\n", (char *) op->a_id);
break;
- case slang_oper_expression:
+ case SLANG_OPER_EXPRESSION:
spaces(indent);
- printf("EXPR: locals %p\n", (void*) op->locals);
- /*print_generic(op, "slang_oper_expression", indent);*/
+ printf("EXPR: locals=%p outer=%p\n",
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
+ /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
slang_print_tree(&op->children[0], indent + 3);
break;
- case slang_oper_if:
+ case SLANG_OPER_IF:
spaces(indent);
printf("IF\n");
slang_print_tree(&op->children[0], indent + 3);
printf("ENDIF\n");
break;
- case slang_oper_while:
+ case SLANG_OPER_WHILE:
assert(op->num_children == 2);
spaces(indent);
+ printf("WHILE LOOP: locals = %p\n", (void *) op->locals);
+ indent += 3;
+ spaces(indent);
printf("WHILE cond:\n");
slang_print_tree(&op->children[0], indent + 3);
spaces(indent);
printf("WHILE body:\n");
slang_print_tree(&op->children[1], indent + 3);
+ indent -= 3;
+ spaces(indent);
+ printf("END WHILE LOOP\n");
break;
- case slang_oper_do:
+ case SLANG_OPER_DO:
+ spaces(indent);
+ printf("DO LOOP: locals = %p\n", (void *) op->locals);
+ indent += 3;
spaces(indent);
printf("DO body:\n");
slang_print_tree(&op->children[0], indent + 3);
spaces(indent);
printf("DO cond:\n");
slang_print_tree(&op->children[1], indent + 3);
+ indent -= 3;
+ spaces(indent);
+ printf("END DO LOOP\n");
break;
- case slang_oper_for:
+ case SLANG_OPER_FOR:
+ spaces(indent);
+ printf("FOR LOOP: locals = %p\n", (void *) op->locals);
+ indent += 3;
spaces(indent);
printf("FOR init:\n");
slang_print_tree(&op->children[0], indent + 3);
spaces(indent);
- printf("FOR while:\n");
+ printf("FOR condition:\n");
slang_print_tree(&op->children[1], indent + 3);
spaces(indent);
printf("FOR step:\n");
spaces(indent);
printf("FOR body:\n");
slang_print_tree(&op->children[3], indent + 3);
+ indent -= 3;
spaces(indent);
printf("ENDFOR\n");
/*
*/
break;
- case slang_oper_void:
+ case SLANG_OPER_VOID:
spaces(indent);
printf("(oper-void)\n");
break;
- case slang_oper_literal_bool:
+ case SLANG_OPER_LITERAL_BOOL:
spaces(indent);
- /*printf("slang_oper_literal_bool\n");*/
- printf("%s\n", op->literal[0] ? "TRUE" : "FALSE");
+ printf("LITERAL (");
+ for (i = 0; i < op->literal_size; i++)
+ printf("%s ", op->literal[0] ? "TRUE" : "FALSE");
+ printf(")\n");
+
break;
- case slang_oper_literal_int:
+ case SLANG_OPER_LITERAL_INT:
spaces(indent);
- /*printf("slang_oper_literal_int\n");*/
- printf("(%d %d %d %d)\n", (int) op->literal[0], (int) op->literal[1],
- (int) op->literal[2], (int) op->literal[3]);
+ printf("LITERAL (");
+ for (i = 0; i < op->literal_size; i++)
+ printf("%d ", (int) op->literal[i]);
+ printf(")\n");
break;
- case slang_oper_literal_float:
+ case SLANG_OPER_LITERAL_FLOAT:
spaces(indent);
- /*printf("slang_oper_literal_float\n");*/
- printf("(%f %f %f %f)\n", op->literal[0], op->literal[1], op->literal[2],
- op->literal[3]);
+ printf("LITERAL (");
+ for (i = 0; i < op->literal_size; i++)
+ printf("%f ", op->literal[i]);
+ printf(")\n");
break;
- case slang_oper_identifier:
- spaces(indent);
- if (op->var && op->var->a_name)
- printf("VAR %s (in scope %p)\n", (char *) op->var->a_name,
- (void *) find_scope(op->locals, op->a_id));
- else
- printf("VAR' %s (in scope %p)\n", (char *) op->a_id,
- (void *) find_scope(op->locals, op->a_id));
+ case SLANG_OPER_IDENTIFIER:
+ {
+ const slang_variable_scope *scope;
+ spaces(indent);
+ if (op->var && op->var->a_name) {
+ scope = find_scope(op->locals, op->var->a_name);
+ printf("VAR %s (in scope %p)\n", (char *) op->var->a_name,
+ (void *) scope);
+ assert(scope);
+ }
+ else {
+ scope = find_scope(op->locals, op->a_id);
+ printf("VAR' %s (in scope %p) locals=%p outer=%p\n",
+ (char *) op->a_id,
+ (void *) scope,
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
+ /*assert(scope);*/
+ }
+ }
break;
- case slang_oper_sequence:
+ case SLANG_OPER_SEQUENCE:
print_generic(op, "COMMA-SEQ", indent+3);
break;
- case slang_oper_assign:
+ case SLANG_OPER_ASSIGN:
spaces(indent);
- printf("ASSIGNMENT locals %p\n", (void*)op->locals);
+ printf("ASSIGNMENT locals=%p outer=%p\n",
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
print_binary(op, ":=", indent);
break;
- case slang_oper_addassign:
+ case SLANG_OPER_ADDASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "+=", indent);
break;
- case slang_oper_subassign:
+ case SLANG_OPER_SUBASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "-=", indent);
break;
- case slang_oper_mulassign:
+ case SLANG_OPER_MULASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "*=", indent);
break;
- case slang_oper_divassign:
+ case SLANG_OPER_DIVASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "/=", indent);
break;
- /*slang_oper_modassign,*/
- /*slang_oper_lshassign,*/
- /*slang_oper_rshassign,*/
- /*slang_oper_orassign,*/
- /*slang_oper_xorassign,*/
- /*slang_oper_andassign,*/
- case slang_oper_select:
+ /*SLANG_OPER_MODASSIGN,*/
+ /*SLANG_OPER_LSHASSIGN,*/
+ /*SLANG_OPER_RSHASSIGN,*/
+ /*SLANG_OPER_ORASSIGN,*/
+ /*SLANG_OPER_XORASSIGN,*/
+ /*SLANG_OPER_ANDASSIGN,*/
+ case SLANG_OPER_SELECT:
spaces(indent);
- printf("slang_oper_select n=%d\n", op->num_children);
+ printf("SLANG_OPER_SELECT n=%d\n", op->num_children);
assert(op->num_children == 3);
slang_print_tree(&op->children[0], indent+3);
spaces(indent);
slang_print_tree(&op->children[2], indent+3);
break;
- case slang_oper_logicalor:
+ case SLANG_OPER_LOGICALOR:
print_binary(op, "||", indent);
break;
- case slang_oper_logicalxor:
+ case SLANG_OPER_LOGICALXOR:
print_binary(op, "^^", indent);
break;
- case slang_oper_logicaland:
+ case SLANG_OPER_LOGICALAND:
print_binary(op, "&&", indent);
break;
- /*slang_oper_bitor*/
- /*slang_oper_bitxor*/
- /*slang_oper_bitand*/
- case slang_oper_equal:
+ /*SLANG_OPER_BITOR*/
+ /*SLANG_OPER_BITXOR*/
+ /*SLANG_OPER_BITAND*/
+ case SLANG_OPER_EQUAL:
print_binary(op, "==", indent);
break;
- case slang_oper_notequal:
+ case SLANG_OPER_NOTEQUAL:
print_binary(op, "!=", indent);
break;
- case slang_oper_less:
+ case SLANG_OPER_LESS:
print_binary(op, "<", indent);
break;
- case slang_oper_greater:
+ case SLANG_OPER_GREATER:
print_binary(op, ">", indent);
break;
- case slang_oper_lessequal:
+ case SLANG_OPER_LESSEQUAL:
print_binary(op, "<=", indent);
break;
- case slang_oper_greaterequal:
+ case SLANG_OPER_GREATEREQUAL:
print_binary(op, ">=", indent);
break;
- /*slang_oper_lshift*/
- /*slang_oper_rshift*/
- case slang_oper_add:
+ /*SLANG_OPER_LSHIFT*/
+ /*SLANG_OPER_RSHIFT*/
+ case SLANG_OPER_ADD:
print_binary(op, "+", indent);
break;
- case slang_oper_subtract:
+ case SLANG_OPER_SUBTRACT:
print_binary(op, "-", indent);
break;
- case slang_oper_multiply:
+ case SLANG_OPER_MULTIPLY:
print_binary(op, "*", indent);
break;
- case slang_oper_divide:
+ case SLANG_OPER_DIVIDE:
print_binary(op, "/", indent);
break;
- /*slang_oper_modulus*/
- case slang_oper_preincrement:
+ /*SLANG_OPER_MODULUS*/
+ case SLANG_OPER_PREINCREMENT:
spaces(indent);
printf("PRE++\n");
slang_print_tree(&op->children[0], indent+3);
break;
- case slang_oper_predecrement:
+ case SLANG_OPER_PREDECREMENT:
spaces(indent);
printf("PRE--\n");
slang_print_tree(&op->children[0], indent+3);
break;
- case slang_oper_plus:
+ case SLANG_OPER_PLUS:
spaces(indent);
- printf("slang_oper_plus\n");
+ printf("SLANG_OPER_PLUS\n");
break;
- case slang_oper_minus:
+ case SLANG_OPER_MINUS:
spaces(indent);
- printf("slang_oper_minus\n");
+ printf("SLANG_OPER_MINUS\n");
break;
- /*slang_oper_complement*/
- case slang_oper_not:
+ /*SLANG_OPER_COMPLEMENT*/
+ case SLANG_OPER_NOT:
spaces(indent);
printf("NOT\n");
slang_print_tree(&op->children[0], indent+3);
break;
- case slang_oper_subscript:
+ case SLANG_OPER_SUBSCRIPT:
spaces(indent);
- printf("slang_oper_subscript\n");
+ printf("SLANG_OPER_SUBSCRIPT locals=%p outer=%p\n",
+ (void *) op->locals,
+ (void *) op->locals->outer_scope);
print_generic(op, NULL, indent+3);
break;
- case slang_oper_call:
+ case SLANG_OPER_CALL:
#if 0
slang_function *fun
- = _slang_locate_function(A->space.funcs, oper->a_id,
+ = _slang_function_locate(A->space.funcs, oper->a_id,
oper->children,
oper->num_children, &A->space, A->atoms);
#endif
printf(")\n");
break;
- case slang_oper_field:
+ case SLANG_OPER_METHOD:
+ spaces(indent);
+ printf("METHOD CALL %s.%s\n", (char *) op->a_obj, (char *) op->a_id);
+ break;
+
+ case SLANG_OPER_FIELD:
spaces(indent);
printf("FIELD %s of\n", (char*) op->a_id);
slang_print_tree(&op->children[0], indent+3);
break;
- case slang_oper_postincrement:
+ case SLANG_OPER_POSTINCREMENT:
spaces(indent);
printf("POST++\n");
slang_print_tree(&op->children[0], indent+3);
break;
- case slang_oper_postdecrement:
+ case SLANG_OPER_POSTDECREMENT:
spaces(indent);
printf("POST--\n");
slang_print_tree(&op->children[0], indent+3);
void
slang_print_function(const slang_function *f, GLboolean body)
{
- int i;
+ GLuint i;
#if 0
if (_mesa_strcmp((char *) f->header.a_name, "main") != 0)
return;
#endif
- printf("FUNCTION %s (\n",
- (char *) f->header.a_name);
+ printf("FUNCTION %s ( scope=%p\n",
+ (char *) f->header.a_name, (void *) f->parameters);
for (i = 0; i < f->param_count; i++) {
- print_variable(&f->parameters->variables[i], 3);
+ print_variable(f->parameters->variables[i], 3);
}
- printf(")\n");
+ printf(") param scope = %p\n", (void *) f->parameters);
+
if (body && f->body)
slang_print_tree(f->body, 0);
}
-/* operation */
-#define OP_END 0
-#define OP_BLOCK_BEGIN_NO_NEW_SCOPE 1
-#define OP_BLOCK_BEGIN_NEW_SCOPE 2
-#define OP_DECLARE 3
-#define OP_ASM 4
-#define OP_BREAK 5
-#define OP_CONTINUE 6
-#define OP_DISCARD 7
-#define OP_RETURN 8
-#define OP_EXPRESSION 9
-#define OP_IF 10
-#define OP_WHILE 11
-#define OP_DO 12
-#define OP_FOR 13
-#define OP_PUSH_VOID 14
-#define OP_PUSH_BOOL 15
-#define OP_PUSH_INT 16
-#define OP_PUSH_FLOAT 17
-#define OP_PUSH_IDENTIFIER 18
-#define OP_SEQUENCE 19
-#define OP_ASSIGN 20
-#define OP_ADDASSIGN 21
-#define OP_SUBASSIGN 22
-#define OP_MULASSIGN 23
-#define OP_DIVASSIGN 24
-/*#define OP_MODASSIGN 25*/
-/*#define OP_LSHASSIGN 26*/
-/*#define OP_RSHASSIGN 27*/
-/*#define OP_ORASSIGN 28*/
-/*#define OP_XORASSIGN 29*/
-/*#define OP_ANDASSIGN 30*/
-#define OP_SELECT 31
-#define OP_LOGICALOR 32
-#define OP_LOGICALXOR 33
-#define OP_LOGICALAND 34
-/*#define OP_BITOR 35*/
-/*#define OP_BITXOR 36*/
-/*#define OP_BITAND 37*/
-#define OP_EQUAL 38
-#define OP_NOTEQUAL 39
-#define OP_LESS 40
-#define OP_GREATER 41
-#define OP_LESSEQUAL 42
-#define OP_GREATEREQUAL 43
-/*#define OP_LSHIFT 44*/
-/*#define OP_RSHIFT 45*/
-#define OP_ADD 46
-#define OP_SUBTRACT 47
-#define OP_MULTIPLY 48
-#define OP_DIVIDE 49
-/*#define OP_MODULUS 50*/
-#define OP_PREINCREMENT 51
-#define OP_PREDECREMENT 52
-#define OP_PLUS 53
-#define OP_MINUS 54
-/*#define OP_COMPLEMENT 55*/
-#define OP_NOT 56
-#define OP_SUBSCRIPT 57
-#define OP_CALL 58
-#define OP_FIELD 59
-#define OP_POSTINCREMENT 60
-#define OP_POSTDECREMENT 61
-
-
-void
-slang_print_opcode(unsigned int opcode)
-{
- switch (opcode) {
- case OP_PUSH_VOID:
- printf("OP_PUSH_VOID\n");
- break;
- case OP_PUSH_BOOL:
- printf("OP_PUSH_BOOL\n");
- break;
- case OP_PUSH_INT:
- printf("OP_PUSH_INT\n");
- break;
- case OP_PUSH_FLOAT:
- printf("OP_PUSH_FLOAT\n");
- break;
- case OP_PUSH_IDENTIFIER:
- printf("OP_PUSH_IDENTIFIER\n");
- break;
- case OP_SEQUENCE:
- printf("OP_SEQUENCE\n");
- break;
- case OP_ASSIGN:
- printf("OP_ASSIGN\n");
- break;
- case OP_ADDASSIGN:
- printf("OP_ADDASSIGN\n");
- break;
- case OP_SUBASSIGN:
- printf("OP_SUBASSIGN\n");
- break;
- case OP_MULASSIGN:
- printf("OP_MULASSIGN\n");
- break;
- case OP_DIVASSIGN:
- printf("OP_DIVASSIGN\n");
- break;
- /*case OP_MODASSIGN:*/
- /*case OP_LSHASSIGN:*/
- /*case OP_RSHASSIGN:*/
- /*case OP_ORASSIGN:*/
- /*case OP_XORASSIGN:*/
- /*case OP_ANDASSIGN:*/
- case OP_SELECT:
- printf("OP_SELECT\n");
- break;
- case OP_LOGICALOR:
- printf("OP_LOGICALOR\n");
- break;
- case OP_LOGICALXOR:
- printf("OP_LOGICALXOR\n");
- break;
- case OP_LOGICALAND:
- printf("OP_LOGICALAND\n");
- break;
- /*case OP_BITOR:*/
- /*case OP_BITXOR:*/
- /*case OP_BITAND:*/
- case OP_EQUAL:
- printf("OP_EQUAL\n");
- break;
- case OP_NOTEQUAL:
- printf("OP_NOTEQUAL\n");
- break;
- case OP_LESS:
- printf("OP_LESS\n");
- break;
- case OP_GREATER:
- printf("OP_GREATER\n");
- break;
- case OP_LESSEQUAL:
- printf("OP_LESSEQUAL\n");
- break;
- case OP_GREATEREQUAL:
- printf("OP_GREATEREQUAL\n");
- break;
- /*case OP_LSHIFT:*/
- /*case OP_RSHIFT:*/
- case OP_ADD:
- printf("OP_ADD\n");
- break;
- case OP_SUBTRACT:
- printf("OP_SUBTRACT\n");
- break;
- case OP_MULTIPLY:
- printf("OP_MULTIPLY\n");
- break;
- case OP_DIVIDE:
- printf("OP_DIVIDE\n");
- break;
- /*case OP_MODULUS:*/
- case OP_PREINCREMENT:
- printf("OP_PREINCREMENT\n");
- break;
- case OP_PREDECREMENT:
- printf("OP_PREDECREMENT\n");
- break;
- case OP_PLUS:
- printf("OP_PLUS\n");
- break;
- case OP_MINUS:
- printf("OP_MINUS\n");
- break;
- case OP_NOT:
- printf("OP_NOT\n");
- break;
- /*case OP_COMPLEMENT:*/
- case OP_SUBSCRIPT:
- printf("OP_SUBSCRIPT\n");
- break;
- case OP_CALL:
- printf("OP_CALL\n");
- break;
- case OP_FIELD:
- printf("OP_FIELD\n");
- break;
- case OP_POSTINCREMENT:
- printf("OP_POSTINCREMENT\n");
- break;
- case OP_POSTDECREMENT:
- printf("OP_POSTDECREMENT\n");
- break;
- default:
- printf("UNKNOWN OP %d\n", opcode);
- }
-}
-
-
-
-const char *
-slang_asm_string(slang_assembly_type t)
-{
- switch (t) {
- /* core */
- case slang_asm_none:
- return "none";
- case slang_asm_float_copy:
- return "float_copy";
- case slang_asm_float_move:
- return "float_move";
- case slang_asm_float_push:
- return "float_push";
- case slang_asm_float_deref:
- return "float_deref";
- case slang_asm_float_add:
- return "float_add";
- case slang_asm_float_multiply:
- return "float_multiply";
- case slang_asm_float_divide:
- return "float_divide";
- case slang_asm_float_negate:
- return "float_negate";
- case slang_asm_float_less:
- return "float_less";
- case slang_asm_float_equal_exp:
- return "float_equal";
- case slang_asm_float_equal_int:
- return "float_equal";
- case slang_asm_float_to_int:
- return "float_to_int";
- case slang_asm_float_sine:
- return "float_sine";
- case slang_asm_float_arcsine:
- return "float_arcsine";
- case slang_asm_float_arctan:
- return "float_arctan";
- case slang_asm_float_power:
- return "float_power";
- case slang_asm_float_log2:
- return "float_log2";
- case slang_asm_vec4_floor:
- return "vec4_floor";
- case slang_asm_float_ceil:
- return "float_ceil";
- case slang_asm_float_noise1:
- return "float_noise1";
- case slang_asm_float_noise2:
- return "float_noise2";
- case slang_asm_float_noise3:
- return "float_noise3";
- case slang_asm_float_noise4:
- return "float_noise4";
- case slang_asm_int_copy:
- return "int_copy";
- case slang_asm_int_move:
- return "int_move";
- case slang_asm_int_push:
- return "int_push";
- case slang_asm_int_deref:
- return "int_deref";
- case slang_asm_int_to_float:
- return "int_to_float";
- case slang_asm_int_to_addr:
- return "int_to_addr";
- case slang_asm_bool_copy:
- return "bool_copy";
- case slang_asm_bool_move:
- return "bool_move";
- case slang_asm_bool_push:
- return "bool_push";
- case slang_asm_bool_deref:
- return "bool_deref";
- case slang_asm_addr_copy:
- return "addr_copy";
- case slang_asm_addr_push:
- return "addr_push";
- case slang_asm_addr_deref:
- return "addr_deref";
- case slang_asm_addr_add:
- return "addr_add";
- case slang_asm_addr_multiply:
- return "addr_multiply";
- case slang_asm_vec4_tex1d:
- return "vec4_tex1d";
- case slang_asm_vec4_tex2d:
- return "vec4_tex2d";
- case slang_asm_vec4_tex3d:
- return "vec4_tex3d";
- case slang_asm_vec4_texcube:
- return "vec4_texcube";
- case slang_asm_vec4_shad1d:
- return "vec4_shad1d";
- case slang_asm_vec4_shad2d:
- return "vec4_shad2d";
- case slang_asm_jump:
- return "jump";
- case slang_asm_jump_if_zero:
- return "jump_if_zero";
- case slang_asm_enter:
- return "enter";
- case slang_asm_leave:
- return "leave";
- case slang_asm_local_alloc:
- return "local_alloc";
- case slang_asm_local_free:
- return "local_free";
- case slang_asm_local_addr:
- return "local_addr";
- case slang_asm_global_addr:
- return "global_addr";
- case slang_asm_call:
- return "call";
- case slang_asm_return:
- return "return";
- case slang_asm_discard:
- return "discard";
- case slang_asm_exit:
- return "exit";
- /* GL_MESA_shader_debug */
- case slang_asm_float_print:
- return "float_print";
- case slang_asm_int_print:
- return "int_print";
- case slang_asm_bool_print:
- return "bool_print";
- /* vec4 */
- case slang_asm_float_to_vec4:
- return "float_to_vec4";
- case slang_asm_vec4_add:
- return "vec4_add";
- case slang_asm_vec4_subtract:
- return "vec4_subtract";
- case slang_asm_vec4_multiply:
- return "vec4_multiply";
- case slang_asm_vec4_divide:
- return "vec4_divide";
- case slang_asm_vec4_negate:
- return "vec4_negate";
- case slang_asm_vec4_dot:
- return "vec4_dot";
- case slang_asm_vec4_copy:
- return "vec4_copy";
- case slang_asm_vec4_deref:
- return "vec4_deref";
- case slang_asm_vec4_equal_int:
- return "vec4_equal";
- default:
- return "??asm??";
- }
-}
-
const char *
slang_type_qual_string(slang_type_qualifier q)
{
switch (q) {
- case slang_qual_none:
+ case SLANG_QUAL_NONE:
return "none";
- case slang_qual_const:
+ case SLANG_QUAL_CONST:
return "const";
- case slang_qual_attribute:
+ case SLANG_QUAL_ATTRIBUTE:
return "attribute";
- case slang_qual_varying:
+ case SLANG_QUAL_VARYING:
return "varying";
- case slang_qual_uniform:
+ case SLANG_QUAL_UNIFORM:
return "uniform";
- case slang_qual_out:
+ case SLANG_QUAL_OUT:
return "out";
- case slang_qual_inout:
+ case SLANG_QUAL_INOUT:
return "inout";
- case slang_qual_fixedoutput:
+ case SLANG_QUAL_FIXEDOUTPUT:
return "fixedoutput";
- case slang_qual_fixedinput:
+ case SLANG_QUAL_FIXEDINPUT:
return "fixedinputk";
default:
return "qual?";
slang_type_string(slang_type_specifier_type t)
{
switch (t) {
- case slang_spec_void:
+ case SLANG_SPEC_VOID:
return "void";
- case slang_spec_bool:
+ case SLANG_SPEC_BOOL:
return "bool";
- case slang_spec_bvec2:
+ case SLANG_SPEC_BVEC2:
return "bvec2";
- case slang_spec_bvec3:
+ case SLANG_SPEC_BVEC3:
return "bvec3";
- case slang_spec_bvec4:
+ case SLANG_SPEC_BVEC4:
return "bvec4";
- case slang_spec_int:
+ case SLANG_SPEC_INT:
return "int";
- case slang_spec_ivec2:
+ case SLANG_SPEC_IVEC2:
return "ivec2";
- case slang_spec_ivec3:
+ case SLANG_SPEC_IVEC3:
return "ivec3";
- case slang_spec_ivec4:
+ case SLANG_SPEC_IVEC4:
return "ivec4";
- case slang_spec_float:
+ case SLANG_SPEC_FLOAT:
return "float";
- case slang_spec_vec2:
+ case SLANG_SPEC_VEC2:
return "vec2";
- case slang_spec_vec3:
+ case SLANG_SPEC_VEC3:
return "vec3";
- case slang_spec_vec4:
+ case SLANG_SPEC_VEC4:
return "vec4";
- case slang_spec_mat2:
+ case SLANG_SPEC_MAT2:
return "mat2";
- case slang_spec_mat3:
+ case SLANG_SPEC_MAT3:
return "mat3";
- case slang_spec_mat4:
+ case SLANG_SPEC_MAT4:
return "mat4";
- case slang_spec_sampler1D:
+ case SLANG_SPEC_SAMPLER1D:
return "sampler1D";
- case slang_spec_sampler2D:
+ case SLANG_SPEC_SAMPLER2D:
return "sampler2D";
- case slang_spec_sampler3D:
+ case SLANG_SPEC_SAMPLER3D:
return "sampler3D";
- case slang_spec_samplerCube:
+ case SLANG_SPEC_SAMPLERCUBE:
return "samplerCube";
- case slang_spec_sampler1DShadow:
+ case SLANG_SPEC_SAMPLER1DSHADOW:
return "sampler1DShadow";
- case slang_spec_sampler2DShadow:
+ case SLANG_SPEC_SAMPLER2DSHADOW:
return "sampler2DShadow";
- case slang_spec_struct:
+ case SLANG_SPEC_SAMPLER2DRECT:
+ return "sampler2DRect";
+ case SLANG_SPEC_SAMPLER2DRECTSHADOW:
+ return "sampler2DRectShadow";
+ case SLANG_SPEC_STRUCT:
return "struct";
- case slang_spec_array:
+ case SLANG_SPEC_ARRAY:
return "array";
default:
return "type?";
}
+#if 0
static char *
slang_var_string(const slang_variable *v)
{
slang_fq_type_string(&v->type));
return str;
}
+#endif
void
printf("Var scope %p %d vars:\n", (void *) vars, vars->num_variables);
for (i = 0; i < vars->num_variables; i++) {
spaces(indent + 3);
- printf("%s\n", (char *) vars->variables[i].a_name);
+ printf("%s (at %p)\n", (char *) vars->variables[i]->a_name, (void*) (vars->variables + i));
}
spaces(indent + 3);
printf("outer_scope = %p\n", (void*) vars->outer_scope);
if (vars->outer_scope) {
- spaces(indent + 3);
+ /*spaces(indent + 3);*/
_slang_print_var_scope(vars->outer_scope, indent + 3);
}
}
slang_checksum_tree(const slang_operation *op)
{
int s = op->num_children;
- int i;
+ GLuint i;
for (i = 0; i < op->num_children; i++) {
s += slang_checksum_tree(&op->children[i]);