Refactor block modification operations into an intermediate base class

[libs/gl.git] / source / programcompiler.cpp

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 9b3266755b0b4f36c7bdc1ebe3471ebba48e8d40..3cb8611c0192be3d08d67798aa9c1c0d6407f09a 100644 (file)
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -159,6 +159,7 @@ void ProgramCompiler::generate(Stage &stage)
 {
        inject_block(stage.content, module->shared.content);
 
+       apply<FunctionResolver>(stage);
        apply<VariableResolver>(stage);
        apply<InterfaceGenerator>(stage);
        apply<VariableResolver>(stage);
@@ -171,6 +172,8 @@ bool ProgramCompiler::optimize(Stage &stage)
        apply<VariableResolver>(stage);
 
        set<Node *> unused = apply<UnusedVariableLocator>(stage);
+       set<Node *> unused2 = apply<UnusedFunctionLocator>(stage);
+       unused.insert(unused2.begin(), unused2.end());
        apply<NodeRemover>(stage, unused);
 
        return !unused.empty();
@@ -616,11 +619,72 @@ void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
 }
 
 
-ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
-       scope_level(0),
+void ProgramCompiler::FunctionResolver::visit(FunctionCall &call)
+{
+       map<string, vector<FunctionDeclaration *> >::iterator i = functions.find(call.name);
+       if(i!=functions.end())
+               call.declaration = i->second.back();
+
+       TraversingVisitor::visit(call);
+}
+
+void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func)
+{
+       vector<FunctionDeclaration *> &decls = functions[func.name];
+       if(func.definition)
+       {
+               for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
+                       (*i)->definition = func.definition;
+               decls.clear();
+               decls.push_back(&func);
+       }
+       else if(!decls.empty() && decls.back()->definition)
+               func.definition = decls.back()->definition;
+       else
+               decls.push_back(&func);
+
+       TraversingVisitor::visit(func);
+}
+
+
+ProgramCompiler::BlockModifier::BlockModifier():
        remove_node(false)
 { }
 
+void ProgramCompiler::BlockModifier::flatten_block(Block &block)
+{
+       for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+               insert_nodes.push_back((*i)->clone());
+       remove_node = true;
+}
+
+void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<NodePtr<Node> >::iterator &i)
+{
+       for(list<Node *>::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j)
+               block.body.insert(i, *j);
+       insert_nodes.clear();
+
+       if(remove_node)
+               block.body.erase(i++);
+       else
+               ++i;
+       remove_node = false;
+}
+
+void ProgramCompiler::BlockModifier::visit(Block &block)
+{
+       for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+       {
+               (*i)->visit(*this);
+               apply_and_increment(block, i);
+       }
+}
+
+
+ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
+       scope_level(0)
+{ }
+
 string ProgramCompiler::InterfaceGenerator::get_out_prefix(StageType type)
 {
        if(type==VERTEX)
@@ -657,15 +721,7 @@ void ProgramCompiler::InterfaceGenerator::visit(Block &block)
                        iface_declarations.clear();
                }
 
-               for(list<Node *>::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j)
-                       block.body.insert(i, *j);
-               insert_nodes.clear();
-
-               if(remove_node)
-                       block.body.erase(i++);
-               else
-                       ++i;
-               remove_node = false;
+               apply_and_increment(block, i);
        }
 }
 
@@ -928,30 +984,13 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
-       scope_level(0),
-       remove_node(false),
-       replacement_block(0)
+       scope_level(0)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
 {
        SetForScope<unsigned> set(scope_level, scope_level+1);
-       for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
-       {
-               (*i)->visit(*this);
-               if(replacement_block)
-               {
-                       for(list<NodePtr<Node> >::iterator j=replacement_block->body.begin(); j!=replacement_block->body.end(); ++j)
-                               block.body.insert(i, *j);
-                       replacement_block = 0;
-               }
-
-               if(remove_node)
-                       block.body.erase(i++);
-               else
-                       ++i;
-               remove_node = false;
-       }
+       BlockModifier::visit(block);
 
        for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
                variable_values.erase(i->second);
@@ -973,10 +1012,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
        ExpressionEvaluator eval(variable_values);
        cond.condition->visit(eval);
        if(eval.result_valid)
-       {
-               remove_node = true;
-               replacement_block = (eval.result ? &cond.body : &cond.else_body);
-       }
+               flatten_block(eval.result ? cond.body : cond.else_body);
        else
                TraversingVisitor::visit(cond);
 }
@@ -1198,6 +1234,24 @@ void ProgramCompiler::UnusedVariableLocator::visit(Iteration &iter)
 }
 
 
+void ProgramCompiler::UnusedFunctionLocator::visit(FunctionCall &call)
+{
+       TraversingVisitor::visit(call);
+
+       unused_nodes.erase(call.declaration);
+       if(call.declaration && call.declaration->definition!=call.declaration)
+               used_definitions.insert(call.declaration->definition);
+}
+
+void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func)
+{
+       TraversingVisitor::visit(func);
+
+       if(func.name!="main" && !used_definitions.count(&func))
+               unused_nodes.insert(&func);
+}
+
+
 ProgramCompiler::NodeRemover::NodeRemover(const set<Node *> &r):
        to_remove(r)
 { }