X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=ed604fffa94849b49efeb34e722b4399f2a88cda;hb=ed3bfcde8987c646157f5450a24c2f5368b3ec9a;hp=2bc3a893e099384e16c663cfdfd601e3a945d85d;hpb=ffdb126a55467245da08a9e6f5669f86e1899bb0;p=libs%2Fgl.git diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index 2bc3a893..ed604fff 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; } @@ -33,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); @@ -68,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) { @@ -82,13 +120,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(); @@ -108,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) @@ -121,23 +156,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) -> %s", var.name, format_type(var.type)); + 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 -> %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(); @@ -147,8 +196,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 -> %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)); assign.left->visit(*this); last_branch(); assign.right->visit(*this); @@ -163,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(); @@ -209,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); @@ -228,66 +309,83 @@ 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) - annotated_branch("Array []", *var.array_size); - - last_branch(); + { + if(var.array_size) + branches.push_back(Branch("Array []", var.array_size.get())); + else + branches.push_back("Array []"); + } 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) { - 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(); } 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) @@ -296,10 +394,17 @@ 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) +{ + if(pass.subscript) + annotated_branch("passthrough[]", *pass.subscript); + else + append("passthrough;"); +} + void DumpTree::visit(Return &ret) { if(ret.expression)