Show node source locations in AST dump

diff --git a/source/glsl/debug.cpp b/source/glsl/debug.cpp
index 810ac742f43e906580d8abe6f69c136514df4dc4..e9eb18c819d00522e4877f49dd04f51b582d2352 100644 (file)
--- a/source/glsl/debug.cpp
+++ b/source/glsl/debug.cpp
@@ -47,6 +47,11 @@ void DumpTree::append(const string &line)
        formatted += '\n';
 }
 
+void DumpTree::append(const Node &node, const string &line)
+{
+       append(format("<%d:%d> %s", node.source, node.line, line));
+}
+
 void DumpTree::append_subtree(const vector<Branch> &branches)
 {
        begin_sub();
@@ -66,6 +71,14 @@ void DumpTree::append_subtree(const vector<Branch> &branches)
        end_sub();
 }
 
+void DumpTree::append_subtree(Node &node)
+{
+       begin_sub();
+       last_branch();
+       node.visit(*this);
+       end_sub();
+}
+
 void DumpTree::begin_sub()
 {
        tree.back() = (tree.back()==BRANCH_LAST ? EMPTY : STRAIGHT);
@@ -117,7 +130,7 @@ typename T::const_iterator DumpTree::increment(typename T::const_iterator &iter,
 
 void DumpTree::visit(Block &block)
 {
-       append(format("Block %s", (block.use_braces ? "{}" : "(inline)")));
+       append(block, format("Block %s", (block.use_braces ? "{}" : "(inline)")));
        begin_sub();
 
        for(std::map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
@@ -143,7 +156,7 @@ void DumpTree::visit(Block &block)
 
 void DumpTree::visit(Literal &literal)
 {
-       append(format("Literal: %s -> %s", literal.token, format_type(literal.type)));
+       append(literal, format("Literal: %s -> %s", literal.token, format_type(literal.type)));
 }
 
 void DumpTree::visit(VariableReference &var)
@@ -152,7 +165,7 @@ void DumpTree::visit(VariableReference &var)
        if(var.declaration)
                text += format("%%%d ", get_label(*var.declaration));
        text += format("%s (var) -> %s", var.name, format_type(var.type));
-       append(text);
+       append(var, text);
 }
 
 void DumpTree::visit(InterfaceBlockReference &iface)
@@ -161,7 +174,7 @@ void DumpTree::visit(InterfaceBlockReference &iface)
        if(iface.declaration)
                text += format("%%%d ", get_label(*iface.declaration));
        text += format("%s (iface) -> %s", iface.name, format_type(iface.type));
-       append(text);
+       append(iface, text);
 }
 
 void DumpTree::visit(MemberAccess &memacc)
@@ -170,7 +183,8 @@ void DumpTree::visit(MemberAccess &memacc)
        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);
+       append(memacc, text);
+       append_subtree(*memacc.left);
 }
 
 void DumpTree::visit(Swizzle &swizzle)
@@ -180,18 +194,20 @@ void DumpTree::visit(Swizzle &swizzle)
        for(unsigned i=0; i<swizzle.count; ++i)
                text += components[swizzle.components[i]];
        text += format(" -> %s", format_type(swizzle.type));
-       annotated_branch(text, *swizzle.left);
+       append(swizzle, text);
+       append_subtree(*swizzle.left);
 }
 
 void DumpTree::visit(UnaryExpression &unary)
 {
        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);
+       append(unary, text);
+       append_subtree(*unary.expression);
 }
 
 void DumpTree::visit(BinaryExpression &binary)
 {
-       append(format("Binary: %s%s -> %s", binary.oper->token, binary.oper->token2, format_type(binary.type)));
+       append(binary, format("Binary: %s%s -> %s", binary.oper->token, binary.oper->token2, format_type(binary.type)));
        begin_sub();
        binary.left->visit(*this);
        last_branch();
@@ -201,7 +217,7 @@ void DumpTree::visit(BinaryExpression &binary)
 
 void DumpTree::visit(Assignment &assign)
 {
-       append(format("Assignment: %s%s -> %s", assign.oper->token, (assign.self_referencing ? " (self-referencing)" : ""), format_type(assign.type)));
+       append(assign, format("Assignment: %s%s -> %s", assign.oper->token, (assign.self_referencing ? " (self-referencing)" : ""), format_type(assign.type)));
        begin_sub();
        if(assign.target.declaration)
        {
@@ -237,7 +253,7 @@ void DumpTree::visit(Assignment &assign)
 
 void DumpTree::visit(TernaryExpression &ternary)
 {
-       append(format("Ternary: %s%s -> %s", ternary.oper->token, ternary.oper->token2, format_type(ternary.type)));
+       append(ternary, 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);
@@ -255,7 +271,7 @@ void DumpTree::visit(FunctionCall &call)
        if(call.constructor)
                head += " (constructor)";
        head += format(" -> %s", format_type(call.type));
-       append(head);
+       append(call, head);
 
        begin_sub();
        for(NodeArray<Expression>::const_iterator i=call.arguments.begin(); i!=call.arguments.end(); )
@@ -268,22 +284,23 @@ void DumpTree::visit(FunctionCall &call)
 
 void DumpTree::visit(ExpressionStatement &expr)
 {
-       annotated_branch("expr;", *expr.expression);
+       append(expr, "expr;");
+       append_subtree(*expr.expression);
 }
 
 void DumpTree::visit(Import &import)
 {
-       append(format("import %s", import.module));
+       append(import, format("import %s", import.module));
 }
 
 void DumpTree::visit(Precision &prec)
 {
-       append(format("precision %s %s", prec.precision, prec.type));
+       append(prec, format("precision %s %s", prec.precision, prec.type));
 }
 
 void DumpTree::visit(Layout &layout)
 {
-       append("Layout");
+       append(layout, "Layout");
        begin_sub();
        for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); )
        {
@@ -298,12 +315,13 @@ void DumpTree::visit(Layout &layout)
 
 void DumpTree::visit(InterfaceLayout &layout)
 {
-       annotated_branch(format("Layout: %s", layout.interface), layout.layout);
+       append(layout, format("Layout: %s", layout.interface));
+       append_subtree(layout.layout);
 }
 
 void DumpTree::visit(BasicTypeDeclaration &type)
 {
-       append(format("%%%d typedef %s", get_label(type), type.name));
+       append(type, format("%%%d typedef %s", get_label(type), type.name));
 
        vector<Branch> branches;
        if(type.base_type)
@@ -319,7 +337,7 @@ void DumpTree::visit(ImageTypeDeclaration &type)
 {
        static const char *dims[] = { "1D", "2D", "3D", "Cube" };
 
-       append(format("%%%d typedef %s", get_label(type), type.name));
+       append(type, format("%%%d typedef %s", get_label(type), type.name));
 
        vector<Branch> branches;
        branches.push_back(format("Dimensions: %s%s", dims[type.dimensions-1], (type.array ? " array" : "")));
@@ -332,7 +350,8 @@ void DumpTree::visit(ImageTypeDeclaration &type)
 
 void DumpTree::visit(StructDeclaration &strct)
 {
-       annotated_branch(format("%%%d struct %s", get_label(strct), strct.name), strct.members);
+       append(strct, format("%%%d struct %s", get_label(strct), strct.name));
+       append_subtree(strct.members);
 }
 
 void DumpTree::visit(VariableDeclaration &var)
@@ -353,7 +372,7 @@ void DumpTree::visit(VariableDeclaration &var)
                decl += " (builtin)";
        else if(var.linked_declaration)
                decl += " (linked)";
-       append(decl);
+       append(var, decl);
 
        vector<Branch> branches;
        if(var.type_declaration)
@@ -386,7 +405,7 @@ void DumpTree::visit(InterfaceBlock &iface)
                head += " (builtin)";
        else if(iface.linked_block)
                head += " (linked)";
-       append(head);
+       append(iface, head);
 
        vector<Branch> branches;
        if(iface.type_declaration)
@@ -405,7 +424,7 @@ void DumpTree::visit(FunctionDeclaration &func)
                text += " (builtin)";
        else if(!func.definition)
                text += " (undefined)";
-       append(text);
+       append(func, text);
 
        begin_sub();
        if(func.return_type_declaration)
@@ -422,7 +441,7 @@ void DumpTree::visit(FunctionDeclaration &func)
 
 void DumpTree::visit(Conditional &cond)
 {
-       append("if()");
+       append(cond, "if()");
 
        vector<Branch> branches;
        branches.push_back(cond.condition.get());
@@ -434,7 +453,7 @@ void DumpTree::visit(Conditional &cond)
 
 void DumpTree::visit(Iteration &iter)
 {
-       append("for()");
+       append(iter, "for()");
 
        begin_sub();
        if(iter.init_statement)
@@ -450,23 +469,21 @@ void DumpTree::visit(Iteration &iter)
 
 void DumpTree::visit(Passthrough &pass)
 {
+       append(pass, (pass.subscript ? "passthrough[]" : "passthrough"));
        if(pass.subscript)
-               annotated_branch("passthrough[]", *pass.subscript);
-       else
-               append("passthrough;");
+               append_subtree(*pass.subscript);
 }
 
 void DumpTree::visit(Return &ret)
 {
+       append(ret, (ret.expression ? "return" : "return;"));
        if(ret.expression)
-               annotated_branch("return", *ret.expression);
-       else
-               append("return;");
+               append_subtree(*ret.expression);
 }
 
 void DumpTree::visit(Jump &jump)
 {
-       append(format("%s;", jump.keyword));
+       append(jump, format("%s;", jump.keyword));
 }
 
 } // namespace SL

diff --git a/source/glsl/debug.h b/source/glsl/debug.h
index a0da24425faa70006af7ad2ce09b49fa67575195..065e7f5dcb7751064253e491941b97c86e8278b9 100644 (file)
--- a/source/glsl/debug.h
+++ b/source/glsl/debug.h
@@ -41,7 +41,9 @@ public:
 
 private:
        void append(const std::string &);
+       void append(const Node &, const std::string &);
        void append_subtree(const std::vector<Branch> &);
+       void append_subtree(Node &);
        void begin_sub();
        void last_branch();
        void end_sub();