X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=99d6edaaa0ab7b7f242e23c0ecc9fc2c04be47df;hb=d8bdf61007978e2c3670a22a58e2f105e8347537;hp=b913f5b493a2b2ad550d5f83903abe74ab68affb;hpb=39141d961e55f56d540b3678f9f8fe94868f2652;p=libs%2Fgl.git diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index b913f5b4..99d6edaa 100644 --- a/source/glsl/debug.cpp +++ b/source/glsl/debug.cpp @@ -14,14 +14,14 @@ const std::string &DumpTree::apply(Stage &stage) tree.push_back(BRANCH); 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) + 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); + string text = format("Interface block: %%%d %s %s", get_label(*i->second), i->second->interface, i->second->block_name); if(!i->second->instance_name.empty()) text += format(" %s", i->second->instance_name); append(text); @@ -47,6 +47,25 @@ void DumpTree::append(const string &line) formatted += '\n'; } +void DumpTree::append_subtree(const vector &branches) +{ + begin_sub(); + for(vector::const_iterator i=branches.begin(); i!=branches.end(); ) + { + vector::const_iterator j = increment(i, branches); + if(!j->text.empty()) + { + if(j->node) + annotated_branch(j->text, *j->node); + else + append(j->text); + } + else + j->node->visit(*this); + } + end_sub(); +} + void DumpTree::begin_sub() { tree.back() = (tree.back()==BRANCH_LAST ? EMPTY : STRAIGHT); @@ -82,6 +101,11 @@ unsigned DumpTree::get_label(const Node &node) return label; } +string DumpTree::format_type(TypeDeclaration *type) +{ + return (type ? type->name : "?"); +} + template typename T::const_iterator DumpTree::increment(typename T::const_iterator &iter, const T &container) { @@ -119,12 +143,7 @@ void DumpTree::visit(Block &block) void DumpTree::visit(Literal &literal) { - append(format("Literal: %s", literal.token)); -} - -void DumpTree::visit(ParenthesizedExpression &parexpr) -{ - annotated_branch("(expr)", *parexpr.expression); + append(format("Literal: %s -> %s", literal.token, format_type(literal.type))); } void DumpTree::visit(VariableReference &var) @@ -132,7 +151,7 @@ void DumpTree::visit(VariableReference &var) string text; if(var.declaration) text += format("%%%d ", get_label(*var.declaration)); - text += format("%s (var)", var.name); + text += format("%s (var) -> %s", var.name, format_type(var.type)); append(text); } @@ -141,7 +160,7 @@ void DumpTree::visit(InterfaceBlockReference &iface) string text; if(iface.declaration) text += format("%%%d ", get_label(*iface.declaration)); - text += format("%s (iface)", iface.name); + text += format("%s (iface) -> %s", iface.name, format_type(iface.type)); append(text); } @@ -150,18 +169,29 @@ void DumpTree::visit(MemberAccess &memacc) string text = "Member access:"; if(memacc.declaration) text += format(" %%%d", get_label(*memacc.declaration)); - text += format(" .%s", memacc.member); + text += format(" .%s -> %s", memacc.member, format_type(memacc.type)); annotated_branch(text, *memacc.left); } +void DumpTree::visit(Swizzle &swizzle) +{ + static const char components[4] = { 'x', 'y', 'z', 'w' }; + string text = "Swizzle: ."; + for(unsigned i=0; i %s", format_type(swizzle.type)); + annotated_branch(text, *swizzle.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 -> %s", unary.oper->token, (unary.oper->type==Operator::PREFIX ? "pre" : "post"), format_type(unary.type)); + annotated_branch(text, *unary.expression); } void DumpTree::visit(BinaryExpression &binary) { - append(format("Binary: %s%s", binary.oper, binary.after)); + append(format("Binary: %s%s -> %s", binary.oper->token, binary.oper->token2, format_type(binary.type))); begin_sub(); binary.left->visit(*this); last_branch(); @@ -171,11 +201,33 @@ 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 -> %s", assign.oper->token, (assign.self_referencing ? " (self-referencing)" : ""), format_type(assign.type))); begin_sub(); - if(assign.target_declaration) + if(assign.target.declaration) { - append(format("Target: %%%d %s %s", get_label(*assign.target_declaration), assign.target_declaration->type, assign.target_declaration->name)); + string text = format("Target: %%%d", get_label(*assign.target.declaration)); + + static const char swizzle[4] = { 'x', 'y', 'z', 'w' }; + for(unsigned i=0; i(component&0xC0)) + { + case Assignment::Target::MEMBER: + text += format(" .%d", component&0x3F); + break; + case Assignment::Target::SWIZZLE: + text += " ."; + for(unsigned j=0; j<4; ++j) + if(component&(1<visit(*this); last_branch(); @@ -183,6 +235,17 @@ void DumpTree::visit(Assignment &assign) end_sub(); } +void DumpTree::visit(TernaryExpression &ternary) +{ + append(format("Ternary: %s%s -> %s", ternary.oper->token, ternary.oper->token2, format_type(ternary.type))); + begin_sub(); + ternary.condition->visit(*this); + ternary.true_expr->visit(*this); + last_branch(); + ternary.false_expr->visit(*this); + end_sub(); +} + void DumpTree::visit(FunctionCall &call) { string head = "Function call: "; @@ -191,6 +254,7 @@ void DumpTree::visit(FunctionCall &call) head += call.name; if(call.constructor) head += " (constructor)"; + head += format(" -> %s", format_type(call.type)); append(head); begin_sub(); @@ -237,6 +301,35 @@ 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)); + + vector branches; + if(type.base_type) + branches.push_back(format("%s: %%%d %s", (type.kind==BasicTypeDeclaration::ALIAS ? "Alias of" : "Base"), get_label(*type.base_type), type.base_type->name)); + if(type.kind==BasicTypeDeclaration::VECTOR) + branches.push_back(format("Vector: %d", type.size)); + else if(type.kind==BasicTypeDeclaration::MATRIX) + branches.push_back(format("Matrix: %dx%d", type.size&0xFFFF, type.size>>16)); + append_subtree(branches); +} + +void DumpTree::visit(ImageTypeDeclaration &type) +{ + static const char *dims[] = { "1D", "2D", "3D", "Cube" }; + + append(format("%%%d typedef %s", get_label(type), type.name)); + + vector branches; + branches.push_back(format("Dimensions: %s%s", dims[type.dimensions-1], (type.array ? " array" : ""))); + if(type.base_type) + branches.push_back(format("Element type: %%%d %s", get_label(*type.base_type), type.base_type->name)); + if(type.shadow) + branches.push_back("Shadow"); + append_subtree(branches); +} + void DumpTree::visit(StructDeclaration &strct) { annotated_branch(format("%%%d struct %s", get_label(strct), strct.name), strct.members); @@ -256,81 +349,93 @@ 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.array && !var.init_expression) - last_branch(); + vector branches; + if(var.type_declaration) + branches.push_back(format("Type: %%%d %s", get_label(*var.type_declaration), var.type_declaration->name)); if(var.layout) - var.layout->visit(*this); - - if(!var.init_expression) - last_branch(); + branches.push_back(var.layout.get()); if(var.array) { if(var.array_size) - annotated_branch("Array []", *var.array_size); + branches.push_back(Branch("Array []", var.array_size.get())); else - append("Array []"); + branches.push_back("Array []"); } - - last_branch(); if(var.init_expression) - var.init_expression->visit(*this); - end_sub(); + branches.push_back(var.init_expression.get()); + append_subtree(branches); } -void DumpTree::visit(InterfaceBlock &block) +void DumpTree::visit(InterfaceBlock &iface) { 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) + if(!iface.instance_name.empty()) + head += format("%%%d ", get_label(iface)); + head += format("%s %s", iface.interface, iface.block_name); + if(!iface.instance_name.empty()) + head += format(" %s", iface.instance_name); + if(iface.array) head += "[]"; - if(block.linked_block) + if(iface.source==BUILTIN_SOURCE) + head += " (builtin)"; + else if(iface.linked_block) head += " (linked)"; - annotated_branch(head, block.members); + append(head); + + begin_sub(); + last_branch(); + if(iface.type_declaration) + append(format("Type: %%%d %s", get_label(*iface.type_declaration), iface.type_declaration->name)); + else if(iface.members) + iface.members->visit(*this); + end_sub(); } void DumpTree::visit(FunctionDeclaration &func) { - append(format("%%%d %s %s()", get_label(func), func.return_type, func.name)); + string text = format("%%%d %s %s%s", get_label(func), func.return_type, func.name, (func.signature.empty() ? "(?)" : func.signature)); + if(func.source==BUILTIN_SOURCE) + text += " (builtin)"; + else if(!func.definition) + text += " (undefined)"; + append(text); + begin_sub(); + if(func.return_type_declaration) + append(format("Return type: %%%d %s", get_label(*func.return_type_declaration), func.return_type_declaration->name)); 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(); } void DumpTree::visit(Conditional &cond) { append("if()"); - begin_sub(); - cond.condition->visit(*this); - if(cond.else_body.body.empty()) - last_branch(); - cond.body.visit(*this); + + vector branches; + branches.push_back(cond.condition.get()); + branches.push_back(&cond.body); if(!cond.else_body.body.empty()) - { - last_branch(); - cond.else_body.visit(*this); - } - end_sub(); + branches.push_back(&cond.else_body); + append_subtree(branches); } void DumpTree::visit(Iteration &iter) { append("for()"); - begin_sub(); + begin_sub(); if(iter.init_statement) annotated_branch("Initialization", *iter.init_statement); if(iter.condition) @@ -339,20 +444,15 @@ void DumpTree::visit(Iteration &iter) annotated_branch("Loop", *iter.loop_expression); last_branch(); annotated_branch("Body", iter.body); - end_sub(); } void DumpTree::visit(Passthrough &pass) { - append("passthrough"); if(pass.subscript) - { - begin_sub(); - last_branch(); - pass.subscript->visit(*this); - end_sub(); - } + annotated_branch("passthrough[]", *pass.subscript); + else + append("passthrough;"); } void DumpTree::visit(Return &ret)