X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=ed604fffa94849b49efeb34e722b4399f2a88cda;hb=ed3bfcde8987c646157f5450a24c2f5368b3ec9a;hp=5397372e611bd7108c3e3da0fc254e4bc9a575b4;hpb=9ec831710f64a62ad5f2e896a55ae82a3519f29e;p=libs%2Fgl.git diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index 5397372e..ed604fff 100644 --- a/source/glsl/debug.cpp +++ b/source/glsl/debug.cpp @@ -14,7 +14,7 @@ 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; @@ -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,12 @@ void DumpTree::visit(Block &block) void DumpTree::visit(Literal &literal) { - append(format("Literal: %s", literal.token)); + append(format("Literal: %s -> %s", literal.token, format_type(literal.type))); } void DumpTree::visit(ParenthesizedExpression &parexpr) { - annotated_branch("(expr)", *parexpr.expression); + annotated_branch(format("(expr) -> %s", format_type(parexpr.type)), *parexpr.expression); } void DumpTree::visit(VariableReference &var) @@ -132,7 +156,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); } @@ -150,18 +174,19 @@ 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(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", (binary.oper->token[0]=='[' ? "[]" : binary.oper->token), format_type(binary.type))); begin_sub(); binary.left->visit(*this); last_branch(); @@ -171,7 +196,7 @@ 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) append(format("Target: %%%d %s %s", get_label(*assign.target_declaration), assign.target_declaration->type, assign.target_declaration->name)); @@ -189,6 +214,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(); @@ -235,6 +261,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); @@ -260,26 +315,21 @@ void DumpTree::visit(VariableDeclaration &var) 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) @@ -307,38 +357,35 @@ void DumpTree::visit(FunctionDeclaration &func) 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); last_branch(); - if(func.definition!=&func) - append(format("Definition: %%%d", get_label(*func.definition))); - else + 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) @@ -347,20 +394,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)