source/glsl/visitor.cpp

   1 #include <msp/core/raii.h>
   2 #include "visitor.h"
   3
   4 using namespace std;
   5
   6 namespace Msp {
   7 namespace GL {
   8 namespace SL {
   9
  10 void NodeVisitor::visit(Assignment &assign)
  11 {
  12         visit(static_cast<BinaryExpression &>(assign));
  13 }
  14
  15
  16 void TraversingVisitor::visit(Block &block)
  17 {
  18         SetForScope<Block *> set_block(current_block, &block);
  19         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
  20                 (*i)->visit(*this);
  21 }
  22
  23 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
  24 {
  25         parexpr.expression->visit(*this);
  26 }
  27
  28 void TraversingVisitor::visit(MemberAccess &memacc)
  29 {
  30         memacc.left->visit(*this);
  31 }
  32
  33 void TraversingVisitor::visit(UnaryExpression &unary)
  34 {
  35         unary.expression->visit(*this);
  36 }
  37
  38 void TraversingVisitor::visit(BinaryExpression &binary)
  39 {
  40         binary.left->visit(*this);
  41         binary.right->visit(*this);
  42 }
  43
  44 void TraversingVisitor::visit(FunctionCall &call)
  45 {
  46         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
  47                 (*i)->visit(*this);
  48 }
  49
  50 void TraversingVisitor::visit(ExpressionStatement &expr)
  51 {
  52         expr.expression->visit(*this);
  53 }
  54
  55 void TraversingVisitor::visit(InterfaceLayout &layout)
  56 {
  57         layout.layout.visit(*this);
  58 }
  59
  60 void TraversingVisitor::visit(StructDeclaration &strct)
  61 {
  62         strct.members.visit(*this);
  63 }
  64
  65 void TraversingVisitor::visit(VariableDeclaration &var)
  66 {
  67         if(var.layout)
  68                 var.layout->visit(*this);
  69         if(var.init_expression)
  70                 var.init_expression->visit(*this);
  71         if(var.array_size)
  72                 var.array_size->visit(*this);
  73 }
  74
  75 void TraversingVisitor::visit(InterfaceBlock &iface)
  76 {
  77         iface.members.visit(*this);
  78 }
  79
  80 void TraversingVisitor::visit(FunctionDeclaration &func)
  81 {
  82         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
  83                 (*i)->visit(*this);
  84         func.body.visit(*this);
  85 }
  86
  87 void TraversingVisitor::visit(Conditional &cond)
  88 {
  89         cond.condition->visit(*this);
  90         cond.body.visit(*this);
  91         cond.else_body.visit(*this);
  92 }
  93
  94 void TraversingVisitor::visit(Iteration &iter)
  95 {
  96         if(iter.init_statement)
  97                 iter.init_statement->visit(*this);
  98         if(iter.condition)
  99                 iter.condition->visit(*this);
 100         if(iter.loop_expression)
 101                 iter.loop_expression->visit(*this);
 102         iter.body.visit(*this);
 103 }
 104
 105 void TraversingVisitor::visit(Passthrough &pass)
 106 {
 107         if(pass.subscript)
 108                 pass.subscript->visit(*this);
 109 }
 110
 111 void TraversingVisitor::visit(Return &ret)
 112 {
 113         if(ret.expression)
 114                 ret.expression->visit(*this);
 115 }
 116
 117
 118 NodeRemover::NodeRemover():
 119         stage(0),
 120         to_remove(0),
 121         anonymous(false),
 122         recursive_remove(false)
 123 { }
 124
 125 void NodeRemover::apply(Stage &s, const set<Node *> &tr)
 126 {
 127         stage = &s;
 128         to_remove = &tr;
 129         s.content.visit(*this);
 130 }
 131
 132 void NodeRemover::remove_variable(map<string, VariableDeclaration *> &vars, VariableDeclaration &decl)
 133 {
 134         map<string, VariableDeclaration *>::iterator i = vars.find(decl.name);
 135         if(i!=vars.end() && i->second==&decl)
 136                 vars.erase(i);
 137 }
 138
 139 void NodeRemover::visit(Block &block)
 140 {
 141         blocks.push_back(&block);
 142         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 143         {
 144                 (*i)->visit(*this);
 145                 if(to_remove->count(i->get()))
 146                         block.body.erase(i++);
 147                 else
 148                         ++i;
 149         }
 150         blocks.pop_back();
 151 }
 152
 153 void NodeRemover::visit(StructDeclaration &strct)
 154 {
 155         if(to_remove->count(&strct))
 156                 blocks.back()->types.erase(strct.name);
 157 }
 158
 159 void NodeRemover::visit(VariableDeclaration &var)
 160 {
 161         if(recursive_remove || to_remove->count(&var))
 162         {
 163                 remove_variable(blocks.back()->variables, var);
 164                 if(anonymous && blocks.size()>1)
 165                         remove_variable(blocks[blocks.size()-2]->variables, var);
 166                 remove_variable(stage->in_variables, var);
 167                 remove_variable(stage->out_variables, var);
 168                 stage->locations.erase(var.name);
 169                 if(var.linked_declaration)
 170                         var.linked_declaration->linked_declaration = 0;
 171         }
 172         else if(var.init_expression && to_remove->count(var.init_expression.get()))
 173                 var.init_expression = 0;
 174 }
 175
 176 void NodeRemover::visit(InterfaceBlock &iface)
 177 {
 178         SetFlag set_anon(anonymous);
 179         SetFlag set_recursive(recursive_remove, recursive_remove || to_remove->count(&iface));
 180         TraversingVisitor::visit(iface);
 181 }
 182
 183 void NodeRemover::visit(Iteration &iter)
 184 {
 185         if(to_remove->count(iter.init_statement.get()))
 186                 iter.init_statement = 0;
 187         TraversingVisitor::visit(iter);
 188 }
 189
 190 } // namespace SL
 191 } // namespace GL
 192 } // namespace Msp