annotated_branch(text, *memacc.left);
}
+void DumpTree::visit(Swizzle &swizzle)
+{
+ static const char components[4] = { 'x', 'y', 'z', 'w' };
+ string text = "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);
+}
+
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));
{
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));
+ if(assign.target.declaration)
+ {
+ string text = format("Target: %%%d", get_label(*assign.target.declaration));
+
+ static const char swizzle[4] = { 'x', 'y', 'z', 'w' };
+ for(unsigned i=0; i<assign.target.chain_len; ++i)
+ {
+ unsigned component = assign.target.chain[i];
+ switch(static_cast<Assignment::Target::ChainType>(component&0xC0))
+ {
+ case Assignment::Target::MEMBER:
+ text += format(" .%d", component&0x3F);
+ break;
+ case Assignment::Target::SWIZZLE:
+ text += " .";
+ for(unsigned j=0; j<4; ++j)
+ if(component&(1<<j))
+ text += swizzle[j];
+ break;
+ case Assignment::Target::ARRAY:
+ text += format(" [%d]", component&0x3F);
+ break;
+ }
+ }
+ append(text);
+ }
assign.left->visit(*this);
last_branch();
assign.right->visit(*this);
append_subtree(branches);
}
-void DumpTree::visit(InterfaceBlock &block)
+void DumpTree::visit(InterfaceBlock &iface)
{
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)
+ if(!iface.instance_name.empty())
+ head += format("%%%d ", get_label(iface));
+ head += format("%s %s", iface.interface, iface.name);
+ if(!iface.instance_name.empty())
+ head += format(" %s", iface.instance_name);
+ if(iface.array)
head += "[]";
- if(block.source==BUILTIN_SOURCE)
+ if(iface.source==BUILTIN_SOURCE)
head += " (builtin)";
- else if(block.linked_block)
+ else if(iface.linked_block)
head += " (linked)";
append(head);
begin_sub();
last_branch();
- if(block.type_declaration)
- append(format("Type: %%%d %s", get_label(*block.type_declaration), block.type_declaration->name));
- else if(block.members)
- block.members->visit(*this);
+ if(iface.type_declaration)
+ append(format("Type: %%%d %s", get_label(*iface.type_declaration), iface.type_declaration->name));
+ else if(iface.members)
+ iface.members->visit(*this);
end_sub();
}
void DumpTree::visit(FunctionDeclaration &func)
{
- string text = format("%%%d %s %s", get_label(func), func.return_type, func.name);
+ string text = format("%%%d %s %s%s", get_label(func), func.return_type, func.name, (func.signature.empty() ? "(?)" : func.signature));
if(func.source==BUILTIN_SOURCE)
text += " (builtin)";
else if(!func.definition)
append(text);
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<VariableDeclaration>::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
(*i)->visit(*this);
last_branch();