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