X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fdebug.cpp;h=77b9025a8776cd8cce3ae83ba26dba54d3c8c0ad;hb=f639d088c478fe5d266f9f5779928735b5176976;hp=04d7aac8ca2c442755efcc1c376f103e6fd3220d;hpb=19a24f859cd7fcf581442319499ae24b3e7385a4;p=libs%2Fgl.git diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp index 04d7aac8..77b9025a 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; @@ -82,6 +82,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 +124,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 +137,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,19 +155,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) { - string text = format("Unary: %s, %sfix", unary.oper->token, (unary.oper->type==Operator::PREFIX ? "pre" : "post")); + 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", (binary.oper->token[0]=='[' ? "[]" : binary.oper->token))); + append(format("Binary: %s -> %s", (binary.oper->token[0]=='[' ? "[]" : binary.oper->token), format_type(binary.type))); begin_sub(); binary.left->visit(*this); last_branch(); @@ -172,7 +177,7 @@ void DumpTree::visit(BinaryExpression &binary) void DumpTree::visit(Assignment &assign) { - append(format("Assignment: %s%s", assign.oper->token, (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)); @@ -190,6 +195,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(); @@ -236,6 +242,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); @@ -262,6 +307,11 @@ void DumpTree::visit(VariableDeclaration &var) 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) @@ -312,10 +362,10 @@ void DumpTree::visit(FunctionDeclaration &func) 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(); }