Remove unused variable and struct declarations from the syntax tree

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

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 1da80bab07871f02befd3a2cc960b22ab1ebd486..92dec9c778913388620f2bcd0dde7e6903a4a276 100644 (file)
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -1,3 +1,4 @@
+#include <msp/core/raii.h>
 #include <msp/strings/format.h>
 #include <msp/strings/utils.h>
 #include "error.h"
@@ -60,6 +61,22 @@ void ProgramCompiler::process()
 void ProgramCompiler::process(Context &context)
 {
        inject_block(context.content, module->global_context.content);
+
+       VariableResolver resolver;
+       context.content.visit(resolver);
+
+       while(1)
+       {
+               UnusedVariableLocator unused_locator;
+               context.content.visit(unused_locator);
+
+               NodeRemover remover;
+               remover.to_remove.insert(unused_locator.unused_variables.begin(), unused_locator.unused_variables.end());
+               context.content.visit(remover);
+
+               if(!remover.n_removed)
+                       break;
+       }
 }
 
 void ProgramCompiler::inject_block(Block &target, const Block &source)
@@ -229,14 +246,13 @@ void ProgramCompiler::Formatter::visit(InterfaceBlock &iface)
 void ProgramCompiler::Formatter::visit(FunctionDeclaration &func)
 {
        formatted += format("%s %s(", func.return_type, func.name);
-       parameter_list = true;
        for(vector<NodePtr<VariableDeclaration> >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
        {
                if(i!=func.parameters.begin())
                        formatted += ", ";
+               SetFlag set(parameter_list);
                (*i)->visit(*this);
        }
-       parameter_list = false;
        formatted += ')';
        if(func.definition)
        {
@@ -263,9 +279,8 @@ void ProgramCompiler::Formatter::visit(Conditional &cond)
        if(!cond.else_body.body.empty())
        {
                formatted += format("\n%selse", string(indent*2, ' '));
-               else_if = true;
+               SetFlag set(else_if);
                cond.else_body.visit(*this);
-               else_if = false;
        }
 }
 
@@ -288,5 +303,157 @@ void ProgramCompiler::Formatter::visit(Return &ret)
        formatted += ';';
 }
 
+
+ProgramCompiler::VariableResolver::VariableResolver():
+       anonymous(false)
+{ }
+
+void ProgramCompiler::VariableResolver::visit(Block &block)
+{
+       blocks.push_back(&block);
+       block.variables.clear();
+       TraversingVisitor::visit(block);
+       blocks.pop_back();
+}
+
+void ProgramCompiler::VariableResolver::visit(VariableReference &var)
+{
+       var.declaration = 0;
+       type = 0;
+       for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
+       {
+               --i;
+               map<string, VariableDeclaration *>::iterator j = (*i)->variables.find(var.name);
+               if(j!=(*i)->variables.end())
+               {
+                       var.declaration = j->second;
+                       type = j->second->type_declaration;
+                       break;
+               }
+       }
+}
+
+void ProgramCompiler::VariableResolver::visit(MemberAccess &memacc)
+{
+       type = 0;
+       TraversingVisitor::visit(memacc);
+       memacc.declaration = 0;
+       if(type)
+       {
+               map<string, VariableDeclaration *>::iterator i = type->members.variables.find(memacc.member);
+               if(i!=type->members.variables.end())
+               {
+                       memacc.declaration = i->second;
+                       type = i->second->type_declaration;
+               }
+               else
+                       type = 0;
+       }
+}
+
+void ProgramCompiler::VariableResolver::visit(BinaryExpression &binary)
+{
+       if(binary.oper=="[")
+       {
+               binary.right->visit(*this);
+               type = 0;
+               binary.left->visit(*this);
+       }
+       else
+       {
+               TraversingVisitor::visit(binary);
+               type = 0;
+       }
+}
+
+void ProgramCompiler::VariableResolver::visit(StructDeclaration &strct)
+{
+       TraversingVisitor::visit(strct);
+       blocks.back()->types[strct.name] = &strct;
+}
+
+void ProgramCompiler::VariableResolver::visit(VariableDeclaration &var)
+{
+       for(vector<Block *>::iterator i=blocks.end(); i!=blocks.begin(); )
+       {
+               --i;
+               map<string, StructDeclaration *>::iterator j = (*i)->types.find(var.type);
+               if(j!=(*i)->types.end())
+                       var.type_declaration = j->second;
+       }
+
+       TraversingVisitor::visit(var);
+       blocks.back()->variables[var.name] = &var;
+       if(anonymous && blocks.size()>1)
+               blocks[blocks.size()-2]->variables[var.name] = &var;
+}
+
+void ProgramCompiler::VariableResolver::visit(InterfaceBlock &iface)
+{
+       SetFlag set(anonymous);
+       TraversingVisitor::visit(iface);
+}
+
+
+void ProgramCompiler::UnusedVariableLocator::visit(VariableReference &var)
+{
+       unused_variables.erase(var.declaration);
+}
+
+void ProgramCompiler::UnusedVariableLocator::visit(MemberAccess &memacc)
+{
+       TraversingVisitor::visit(memacc);
+       unused_variables.erase(memacc.declaration);
+}
+
+void ProgramCompiler::UnusedVariableLocator::visit(VariableDeclaration &var)
+{
+       unused_variables.insert(&var);
+       TraversingVisitor::visit(var);
+}
+
+
+ProgramCompiler::NodeRemover::NodeRemover():
+       n_removed(0),
+       immutable_block(false),
+       remove_block(false)
+{ }
+
+void ProgramCompiler::NodeRemover::visit(Block &block)
+{
+       remove_block = immutable_block;
+       for(list<NodePtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+       {
+               bool remove = false;
+               if(to_remove.count(&**i))
+                       remove = !immutable_block;
+               else
+               {
+                       remove_block = false;
+                       (*i)->visit(*this);
+                       remove = remove_block;
+               }
+
+               if(remove)
+                       block.body.erase(i++);
+               else
+                       ++i;
+
+               n_removed += remove;
+       }
+}
+
+void ProgramCompiler::NodeRemover::visit(StructDeclaration &strct)
+{
+       SetFlag set(immutable_block);
+       TraversingVisitor::visit(strct);
+}
+
+void ProgramCompiler::NodeRemover::visit(InterfaceBlock &iface)
+{
+       SetFlag set(immutable_block);
+       TraversingVisitor::visit(iface);
+}
+
 } // namespace GL
 } // namespace Msp