X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=60b7c2477cf093664f4fc2ac8bcfdb52f56fb5b1;hp=2e8433f28287713ca215c0a33e0df669cd6b1f55;hb=HEAD;hpb=aa834c69698b5f0804a19fee4ec2e632a51e38c2 diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index 2e8433f2..a090c362 100644 --- a/source/glsl/debug.cpp +++ b/source/glsl/debug.cpp @@ -8,27 +8,38 @@ namespace Msp { namespace GL { namespace SL { -const std::string &DumpTree::apply(Stage &stage) +const DumpTree::Colors DumpTree::no_colors = +{ "", "", "", "", "", "", "" }; + +const DumpTree::Colors DumpTree::default_colors = +{ + "\033[0m", // default + "\033[38;5;250m", // tree + "\033[38;5;244m", // location + "\033[38;5;146m", // label + "\033[38;5;194m", // type + "\033[38;5;230m", // name + "\033[38;5;210m" // error +}; + +DumpTree::DumpTree(bool use_colors): + colors(use_colors ? default_colors : no_colors) +{ } + +string DumpTree::apply(Stage &stage) { formatted = format("Stage: %s\n", Stage::get_stage_name(stage.type)); - tree.push_back(BRANCH); + begin_sub(); 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)); + for(const auto &kvp: stage.types) + append(format("Type: %s %s%s%s", get_label(*kvp.second), colors.type_color, kvp.first, colors.default_color)); - 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->block_name); - if(!i->second->instance_name.empty()) - text += format(" %s", i->second->instance_name); - append(text); - } + for(const auto &kvp: stage.interface_blocks) + append(format("Interface block: %s %s", get_label(*kvp.second), format_name(kvp.first))); - 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)); + for(const auto &kvp: stage.functions) + append(format("Function: %s %s", get_label(*kvp.second), format_name(kvp.first))); last_branch(); stage.content.visit(*this); @@ -37,27 +48,38 @@ const std::string &DumpTree::apply(Stage &stage) void DumpTree::append(const string &line) { + formatted += colors.tree_color; StringCodec::Utf8::Encoder enc; - for(vector::const_iterator i=tree.begin(); i!=tree.end(); ) + for(auto i=tree.begin(); i!=tree.end(); ) { enc.encode_char(*i++, formatted); enc.encode_char((i==tree.end() ? REACH : EMPTY), formatted); } + formatted += colors.default_color; formatted += line; formatted += '\n'; } void DumpTree::append(const Node &node, const string &line) { - append(format("<%d:%d> %s", node.source, node.line, line)); + string location; + if(node.source==BUILTIN_SOURCE) + location = "builtin"; + else if(node.source==INTERNAL_SOURCE) + location = "internal"; + else if(node.source==GENERATED_SOURCE) + location = "generated"; + else + location = format("%s:%s", node.source, node.line); + append(format("%s<%s>%s %s", colors.location_color, location, colors.default_color, line)); } void DumpTree::append_subtree(const vector &branches) { begin_sub(); - for(vector::const_iterator i=branches.begin(); i!=branches.end(); ) + for(auto i=branches.begin(); i!=branches.end(); ) { - vector::const_iterator j = increment(i, branches); + auto j = increment(i, branches); if(!j->text.empty()) { append(j->text); @@ -85,7 +107,8 @@ void DumpTree::append_subtree(Node &node) void DumpTree::begin_sub() { - tree.back() = (tree.back()==BRANCH_LAST ? EMPTY : STRAIGHT); + if(!tree.empty()) + tree.back() = (tree.back()==BRANCH_LAST ? EMPTY : STRAIGHT); tree.push_back(BRANCH); } @@ -97,27 +120,37 @@ void DumpTree::last_branch() void DumpTree::end_sub() { tree.pop_back(); - if(tree.back()==STRAIGHT) + if(!tree.empty() && tree.back()==STRAIGHT) tree.back() = BRANCH; } -unsigned DumpTree::get_label(const Node &node) +std::string DumpTree::get_label(const Node &node) { unsigned &label = node_labels[&node]; if(!label) label = node_labels.size(); - return label; + return format("%s%%%d%s", colors.label_color, label, colors.default_color); } string DumpTree::format_type(TypeDeclaration *type) { - return (type ? type->name : "?"); + return type ? format_type(type->name) : format("%s?%s", colors.error_color, colors.default_color); +} + +string DumpTree::format_type(const string &type) +{ + return format("%s%s%s", colors.type_color, type, colors.default_color); +} + +string DumpTree::format_name(const string &name) +{ + return format("%s%s%s", colors.name_color, name, colors.default_color); } template typename T::const_iterator DumpTree::increment(typename T::const_iterator &iter, const T &container) { - typename T::const_iterator ret = iter++; + auto ret = iter++; if(iter==container.end()) last_branch(); return ret; @@ -128,12 +161,12 @@ void DumpTree::visit(Block &block) append(block, format("Block %s", (block.use_braces ? "{}" : "(inline)"))); begin_sub(); - 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)); + for(const auto &kvp: block.variables) + append(format("Variable: %s %s %s", get_label(*kvp.second), format_type(kvp.second->type), format_name(kvp.first))); - for(NodeList::const_iterator i=block.body.begin(); i!=block.body.end(); ) + for(auto i=block.body.cbegin(); i!=block.body.cend(); ) { - NodeList::const_iterator j = increment(i, block.body); + auto j = increment(i, block.body); (*j)->visit(*this); } @@ -149,26 +182,17 @@ void DumpTree::visit(VariableReference &var) { string text; if(var.declaration) - text += format("%%%d ", get_label(*var.declaration)); - text += format("%s (var) -> %s", var.name, format_type(var.type)); + text += format("%s ", get_label(*var.declaration)); + text += format("%s -> %s", format_name(var.name), format_type(var.type)); append(var, text); } -void DumpTree::visit(InterfaceBlockReference &iface) -{ - string text; - if(iface.declaration) - text += format("%%%d ", get_label(*iface.declaration)); - text += format("%s (iface) -> %s", iface.name, format_type(iface.type)); - append(iface, text); -} - void DumpTree::visit(MemberAccess &memacc) { string text = "Member access:"; if(memacc.declaration) - text += format(" %%%d", get_label(*memacc.declaration)); - text += format(" .%s -> %s", memacc.member, format_type(memacc.type)); + text += format(" %s", get_label(*memacc.declaration)); + text += format(" .%s (%d) -> %s", format_name(memacc.member), memacc.index, format_type(memacc.type)); append(memacc, text); append_subtree(*memacc.left); } @@ -207,7 +231,7 @@ void DumpTree::visit(Assignment &assign) begin_sub(); if(assign.target.declaration) { - string text = format("Target: %%%d", get_label(*assign.target.declaration)); + string text = format("Target: %s", get_label(*assign.target.declaration)); static const char swizzle[4] = { 'x', 'y', 'z', 'w' }; for(unsigned i=0; i %s", format_type(call.type)); append(call, head); begin_sub(); - for(NodeArray::const_iterator i=call.arguments.begin(); i!=call.arguments.end(); ) + for(auto i=call.arguments.cbegin(); i!=call.arguments.cend(); ) { - NodeArray::const_iterator j = increment(i, call.arguments); + auto j = increment(i, call.arguments); (*j)->visit(*this); } end_sub(); @@ -288,9 +312,9 @@ void DumpTree::visit(Layout &layout) { append(layout, "Layout"); begin_sub(); - for(vector::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ) + for(auto i=layout.qualifiers.cbegin(); i!=layout.qualifiers.cend(); ) { - vector::const_iterator j = increment(i, layout.qualifiers); + auto j = increment(i, layout.qualifiers); string qualifier = j->name; if(j->has_value) qualifier += format("=%d", j->value); @@ -307,42 +331,56 @@ void DumpTree::visit(InterfaceLayout &layout) void DumpTree::visit(BasicTypeDeclaration &type) { - append(type, format("%%%d typedef %s", get_label(type), type.name)); + append(type, format("%s typedef %s", get_label(type), format_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)); + branches.emplace_back(format("%s: %s %s", (type.kind==BasicTypeDeclaration::ALIAS ? "Alias of" : "Base"), get_label(*type.base_type), format_type(type.base_type->name))); if(type.kind==BasicTypeDeclaration::VECTOR) - branches.push_back(format("Vector: %d", type.size)); + branches.emplace_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)); + branches.emplace_back(format("Matrix: %dx%d", type.size&0xFFFF, type.size>>16)); + if(type.extended_alignment) + branches.emplace_back("Extended alignment"); append_subtree(branches); } void DumpTree::visit(ImageTypeDeclaration &type) { - static const char *dims[] = { "1D", "2D", "3D", "Cube" }; + static const char *const dims[] = { "1D", "2D", "3D", "Cube" }; - append(type, format("%%%d typedef %s", get_label(type), type.name)); + append(type, format("%s typedef %s", get_label(type), format_type(type.name))); vector branches; - branches.push_back(format("Dimensions: %s%s", dims[type.dimensions-1], (type.array ? " array" : ""))); + branches.emplace_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)); + branches.emplace_back(format("Element type: %s %s", get_label(*type.base_type), format_type(type.base_type->name))); + if(!type.format.empty()) + branches.emplace_back(format("Texel format: %s", type.format)); + if(type.sampled) + branches.emplace_back("Sampled"); if(type.shadow) - branches.push_back("Shadow"); + branches.emplace_back("Shadow"); + if(type.multisample) + branches.emplace_back("Multisample"); append_subtree(branches); } void DumpTree::visit(StructDeclaration &strct) { - append(strct, format("%%%d struct %s", get_label(strct), strct.name)); - append_subtree(strct.members); + append(strct, format("%s struct %s", get_label(strct), strct.name)); + vector branches; + if(!strct.block_name.empty()) + branches.emplace_back(format("Interface block: %s", format_name(strct.block_name))); + if(strct.extended_alignment) + branches.emplace_back("Extended alignment"); + branches.emplace_back(&strct.members); + append_subtree(branches); } void DumpTree::visit(VariableDeclaration &var) { - string decl = format("%%%d ", get_label(var)); + string decl = format("%s ", get_label(var)); if(var.constant) decl += "const "; if(!var.interpolation.empty()) @@ -353,7 +391,7 @@ void DumpTree::visit(VariableDeclaration &var) decl += format("%s ", var.interface); if(!var.precision.empty()) decl += format("%s ", var.precision); - decl += format("%s %s", var.type, var.name); + decl += format("%s %s", format_type(var.type), format_name(var.name)); if(var.source==BUILTIN_SOURCE) decl += " (builtin)"; else if(var.linked_declaration) @@ -362,50 +400,26 @@ void DumpTree::visit(VariableDeclaration &var) vector branches; if(var.type_declaration) - branches.push_back(format("Type: %%%d %s", get_label(*var.type_declaration), var.type_declaration->name)); + branches.emplace_back(format("Type: %s %s", get_label(*var.type_declaration), format_type(var.type_declaration->name))); + if(var.block_declaration) + branches.emplace_back(format("Interface block: %s", format_name(var.block_declaration->block_name))); if(var.layout) - branches.push_back(var.layout.get()); + branches.emplace_back(var.layout.get()); if(var.array) { if(var.array_size) - branches.push_back(Branch("Array []", var.array_size.get())); + branches.emplace_back("Array []", var.array_size.get()); else - branches.push_back("Array []"); + branches.emplace_back("Array []"); } if(var.init_expression) - branches.push_back(var.init_expression.get()); - append_subtree(branches); -} - -void DumpTree::visit(InterfaceBlock &iface) -{ - string head; - 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(iface.source==BUILTIN_SOURCE) - head += " (builtin)"; - else if(iface.linked_block) - head += " (linked)"; - append(iface, head); - - vector branches; - if(iface.type_declaration) - append(format("Type: %%%d %s", get_label(*iface.type_declaration), iface.type_declaration->name)); - if(iface.layout) - branches.push_back(iface.layout.get()); - if(iface.members) - branches.push_back(iface.members.get()); + branches.emplace_back(var.init_expression.get()); append_subtree(branches); } void DumpTree::visit(FunctionDeclaration &func) { - string text = format("%%%d %s %s%s", get_label(func), func.return_type, func.name, (func.signature.empty() ? "(?)" : func.signature)); + string text = format("%s %s %s%s", get_label(func), format_type(func.return_type), format_name(func.name), (func.signature.empty() ? "(?)" : func.signature)); if(func.source==BUILTIN_SOURCE) text += " (builtin)"; else if(!func.definition) @@ -414,14 +428,14 @@ void DumpTree::visit(FunctionDeclaration &func) 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); + append(format("Return type: %s %s", get_label(*func.return_type_declaration), format_type(func.return_type_declaration))); + for(const RefPtr &p: func.parameters) + p->visit(*this); last_branch(); if(func.definition==&func) func.body.visit(*this); else if(func.definition) - append(format("Definition: %%%d", get_label(*func.definition))); + append(format("Definition: %s", get_label(*func.definition))); end_sub(); } @@ -430,10 +444,10 @@ void DumpTree::visit(Conditional &cond) append(cond, "if()"); vector branches; - branches.push_back(cond.condition.get()); - branches.push_back(Branch("then", &cond.body)); + branches.emplace_back(cond.condition.get()); + branches.emplace_back("then", &cond.body); if(!cond.else_body.body.empty()) - branches.push_back(Branch("else", &cond.else_body)); + branches.emplace_back("else", &cond.else_body); append_subtree(branches); } @@ -443,12 +457,12 @@ void DumpTree::visit(Iteration &iter) vector branches; if(iter.init_statement) - branches.push_back(Branch("Initialization", iter.init_statement.get())); + branches.emplace_back("Initialization", iter.init_statement.get()); if(iter.condition) - branches.push_back(Branch("Condition", iter.condition.get())); + branches.emplace_back("Condition", iter.condition.get()); if(iter.loop_expression) - branches.push_back(Branch("Loop", iter.loop_expression.get())); - branches.push_back(&iter.body); + branches.emplace_back("Loop", iter.loop_expression.get()); + branches.emplace_back(&iter.body); append_subtree(branches); }