X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=d49b9a5f142e8a09b29bcc304e7c29056b87f412;hb=e97feb2fdd27af970412eea6a03cc7270032a80b;hp=0a5b6ef375be2efccb77261fdf6c9e124c4f2b05;hpb=48fa4e32b654aa1f2107caf266c3bdda9cc74847;p=libs%2Fgl.git diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index 0a5b6ef3..d49b9a5f 100644 --- a/source/glsl/debug.cpp +++ b/source/glsl/debug.cpp @@ -10,14 +10,28 @@ namespace SL { const std::string &DumpTree::apply(Stage &stage) { - formatted = format("Stage %s\n", Stage::get_stage_name(stage.type)); + formatted = format("Stage: %s\n", Stage::get_stage_name(stage.type)); tree.push_back(BRANCH); - for(map::const_iterator i=stage.in_variables.begin(); i!=stage.in_variables.end(); ++i) - append(format("Input: %%%d %s %s", get_label(*i->second), i->second->type, i->first)); - for(map::const_iterator i=stage.out_variables.begin(); i!=stage.out_variables.end(); ++i) - append(format("Output: %%%d %s %s", get_label(*i->second), i->second->type, i->first)); + append(format("Version: %d.%02d", stage.required_features.glsl_version.major, stage.required_features.glsl_version.minor)); + + for(std::map::const_iterator i=stage.types.begin(); i!=stage.types.end(); ++i) + append(format("Type: %%%d %s", get_label(*i->second), i->first)); + + set seen_interfaces; + for(std::map::const_iterator i=stage.interface_blocks.begin(); i!=stage.interface_blocks.end(); ++i) + if(seen_interfaces.insert(i->second).second) + { + string text = format("Interface block: %%%d %s %s", get_label(*i->second), i->second->interface, i->second->name); + if(!i->second->instance_name.empty()) + text += format(" %s", i->second->instance_name); + append(text); + } + + for(std::map::const_iterator i=stage.functions.begin(); i!=stage.functions.end(); ++i) + append(format("Function: %%%d %s", get_label(*i->second), i->first)); + last_branch(); - visit(stage.content); + stage.content.visit(*this); return formatted; } @@ -82,13 +96,10 @@ void DumpTree::visit(Block &block) append(format("Block %s", (block.use_braces ? "{}" : "(inline)"))); begin_sub(); - for(std::map::const_iterator i=block.types.begin(); i!=block.types.end(); ++i) - append(format("Type %%%d %s", get_label(*i->second), i->first)); - for(std::map::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i) - append(format("Variable %%%d %s %s", get_label(*i->second), i->second->type, i->first)); + append(format("Variable: %%%d %s %s", get_label(*i->second), i->second->type, i->first)); - bool labeled_body = (!block.types.empty() || !block.variables.empty()); + bool labeled_body = !block.variables.empty(); if(labeled_body) { last_branch(); @@ -121,23 +132,37 @@ void DumpTree::visit(VariableReference &var) string text; if(var.declaration) text += format("%%%d ", get_label(*var.declaration)); - text += var.name; + text += format("%s (var)", var.name); + append(text); +} + +void DumpTree::visit(InterfaceBlockReference &iface) +{ + string text; + if(iface.declaration) + text += format("%%%d ", get_label(*iface.declaration)); + text += format("%s (iface)", iface.name); append(text); } void DumpTree::visit(MemberAccess &memacc) { - annotated_branch(format("Member access: .%s", memacc.member), *memacc.left); + string text = "Member access:"; + if(memacc.declaration) + text += format(" %%%d", get_label(*memacc.declaration)); + text += format(" .%s", memacc.member); + annotated_branch(text, *memacc.left); } void DumpTree::visit(UnaryExpression &unary) { - annotated_branch(format("Unary: %s, %sfix", unary.oper, (unary.prefix ? "pre" : "suff")), *unary.expression); + string text = format("Unary: %s, %sfix", unary.oper->token, (unary.oper->type==Operator::PREFIX ? "pre" : "post")); + annotated_branch(text, *unary.expression); } void DumpTree::visit(BinaryExpression &binary) { - append(format("Binary: %s%s", binary.oper, binary.after)); + append(format("Binary: %s", (binary.oper->token[0]=='[' ? "[]" : binary.oper->token))); begin_sub(); binary.left->visit(*this); last_branch(); @@ -147,8 +172,10 @@ void DumpTree::visit(BinaryExpression &binary) void DumpTree::visit(Assignment &assign) { - append(format("Assignment: %s%s", assign.oper, (assign.self_referencing ? " (self-referencing)" : ""))); + append(format("Assignment: %s%s", assign.oper->token, (assign.self_referencing ? " (self-referencing)" : ""))); begin_sub(); + if(assign.target_declaration) + append(format("Target: %%%d %s %s", get_label(*assign.target_declaration), assign.target_declaration->type, assign.target_declaration->name)); assign.left->visit(*this); last_branch(); assign.right->visit(*this); @@ -196,9 +223,9 @@ void DumpTree::visit(Layout &layout) for(vector::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ) { vector::const_iterator j = increment(i, layout.qualifiers); - string qualifier = j->identifier; - if(!j->value.empty()) - qualifier += format("=%s", j->value); + string qualifier = j->name; + if(j->has_value) + qualifier += format("=%d", j->value); append(qualifier); } end_sub(); @@ -209,6 +236,45 @@ void DumpTree::visit(InterfaceLayout &layout) annotated_branch(format("Layout: %s", layout.interface), layout.layout); } +void DumpTree::visit(BasicTypeDeclaration &type) +{ + append(format("%%%d typedef %s", get_label(type), type.name)); + begin_sub(); + if(type.kind!=BasicTypeDeclaration::VECTOR && type.kind!=BasicTypeDeclaration::MATRIX) + last_branch(); + if(type.base_type) + append(format("%s: %%%d %s", (type.kind==BasicTypeDeclaration::ALIAS ? "Alias of" : "Base"), get_label(*type.base_type), type.base_type->name)); + + last_branch(); + if(type.kind==BasicTypeDeclaration::VECTOR) + append(format("Vector: %d", type.size)); + else if(type.kind==BasicTypeDeclaration::MATRIX) + append(format("Matrix: %dx%d", type.size&0xFFFF, type.size>>16)); + end_sub(); +} + +void DumpTree::visit(ImageTypeDeclaration &type) +{ + append(format("%%%d typedef %s", get_label(type), type.name)); + begin_sub(); + + if(!type.shadow && !type.base_type) + last_branch(); + static const char *dims[] = { "1D", "2D", "3D", "Cube" }; + append(format("Dimensions: %s%s", dims[type.dimensions-1], (type.array ? " array" : ""))); + + if(!type.shadow) + last_branch(); + if(type.base_type) + append(format("Element type: %%%d %s", get_label(*type.base_type), type.base_type->name)); + + last_branch(); + if(type.shadow) + append("Shadow"); + + end_sub(); +} + void DumpTree::visit(StructDeclaration &strct) { annotated_branch(format("%%%d struct %s", get_label(strct), strct.name), strct.members); @@ -228,11 +294,18 @@ void DumpTree::visit(VariableDeclaration &var) if(!var.precision.empty()) decl += format("%s ", var.precision); decl += format("%s %s", var.type, var.name); - if(var.linked_declaration) + if(var.source==BUILTIN_SOURCE) + decl += " (builtin)"; + else if(var.linked_declaration) decl += " (linked)"; append(decl); begin_sub(); + if(!var.layout && !var.array && !var.init_expression) + last_branch(); + if(var.type_declaration) + append(format("Type: %%%d %s", get_label(*var.type_declaration), var.type_declaration->name)); + if(!var.array && !var.init_expression) last_branch(); if(var.layout) @@ -241,7 +314,12 @@ void DumpTree::visit(VariableDeclaration &var) if(!var.init_expression) last_branch(); if(var.array) - annotated_branch("Array []", *var.array_size); + { + if(var.array_size) + annotated_branch("Array []", *var.array_size); + else + append("Array []"); + } last_branch(); if(var.init_expression) @@ -251,19 +329,37 @@ void DumpTree::visit(VariableDeclaration &var) void DumpTree::visit(InterfaceBlock &block) { - annotated_branch(format("%s %s", block.interface, block.name), block.members); + string head; + if(!block.instance_name.empty()) + head += format("%%%d ", get_label(block)); + head += format("%s %s", block.interface, block.name); + if(!block.instance_name.empty()) + head += format(" %s", block.instance_name); + if(block.array) + head += "[]"; + if(block.source==BUILTIN_SOURCE) + head += " (builtin)"; + else if(block.linked_block) + head += " (linked)"; + annotated_branch(head, block.members); } void DumpTree::visit(FunctionDeclaration &func) { - append(format("%%%d %s %s()", get_label(func), func.return_type, func.name)); + string text = format("%%%d %s %s", get_label(func), func.return_type, func.name); + if(func.source==BUILTIN_SOURCE) + text += " (builtin)"; + else if(!func.definition) + text += " (undefined)"; + append(text); begin_sub(); for(NodeArray::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) (*i)->visit(*this); - if(func.definition) - append(format("Definition %%%d", get_label(*func.definition))); last_branch(); - func.body.visit(*this); + if(func.definition==&func) + func.body.visit(*this); + else if(func.definition) + append(format("Definition: %%%d", get_label(*func.definition))); end_sub(); } @@ -300,6 +396,18 @@ void DumpTree::visit(Iteration &iter) end_sub(); } +void DumpTree::visit(Passthrough &pass) +{ + append("passthrough"); + if(pass.subscript) + { + begin_sub(); + last_branch(); + pass.subscript->visit(*this); + end_sub(); + } +} + void DumpTree::visit(Return &ret) { if(ret.expression)