block.variables.clear();
}
-void VariableResolver::visit_and_replace(RefPtr<Expression> &expr)
+void VariableResolver::visit(RefPtr<Expression> &expr)
{
r_replacement_expr = 0;
expr->visit(*this);
void VariableResolver::visit(MemberAccess &memacc)
{
- visit_and_replace(memacc.left);
+ TraversingVisitor::visit(memacc);
VariableDeclaration *declaration = 0;
if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(memacc.left->type))
void VariableResolver::visit(Swizzle &swizzle)
{
- visit_and_replace(swizzle.left);
+ TraversingVisitor::visit(swizzle);
if(record_target)
{
}
}
-void VariableResolver::visit(UnaryExpression &unary)
-{
- visit_and_replace(unary.expression);
-}
-
void VariableResolver::visit(BinaryExpression &binary)
{
if(binary.oper->token[0]=='[')
/* The subscript expression is not a part of the primary assignment
target. */
SetFlag set(record_target, false);
- visit_and_replace(binary.right);
+ visit(binary.right);
}
- visit_and_replace(binary.left);
+ visit(binary.left);
if(record_target)
{
}
}
else
- {
- visit_and_replace(binary.left);
- visit_and_replace(binary.right);
- }
+ TraversingVisitor::visit(binary);
}
void VariableResolver::visit(Assignment &assign)
{
SetFlag set(record_target);
r_assignment_target = Assignment::Target();
- visit_and_replace(assign.left);
+ visit(assign.left);
r_any_resolved |= (r_assignment_target<assign.target || assign.target<r_assignment_target);
assign.target = r_assignment_target;
}
r_self_referencing = false;
- visit_and_replace(assign.right);
+ visit(assign.right);
assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='=');
}
-void VariableResolver::visit(FunctionCall &call)
-{
- for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
- visit_and_replace(*i);
-}
-
void VariableResolver::visit(VariableDeclaration &var)
{
- if(var.layout)
- var.layout->visit(*this);
- if(var.array_size)
- visit_and_replace(var.array_size);
- if(var.init_expression)
- visit_and_replace(var.init_expression);
+ TraversingVisitor::visit(var);
current_block->variables.insert(make_pair(var.name, &var));
}
void FunctionResolver::visit(FunctionCall &call)
{
map<string, FunctionDeclaration *>::iterator i = stage->functions.find(call.name);
- if(i!=stage->functions.end())
- call.declaration = i->second;
+ FunctionDeclaration *declaration = (i!=stage->functions.end() ? i->second : 0);
+ r_any_resolved |= (declaration!=call.declaration);
+ call.declaration = declaration;
TraversingVisitor::visit(call);
}
// Set all previous declarations to use this definition.
for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
{
+ r_any_resolved |= (func.definition!=(*i)->definition);
(*i)->definition = func.definition;
(*i)->body.body.clear();
}
}
else
{
- func.definition = 0;
+ FunctionDeclaration *definition = (stage_decl ? stage_decl->definition : 0);
+ r_any_resolved |= (definition!=func.definition);
+ func.definition = definition;
+
if(!stage_decl)
stage_decl = &func;
- else
- func.definition = stage_decl->definition;
}
decls.push_back(&func);