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 BlockModifier::BlockModifier():
 118         remove_node(false)
 119 { }
 120
 121 void BlockModifier::flatten_block(Block &block)
 122 {
 123         insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
 124         remove_node = true;
 125 }
 126
 127 void BlockModifier::apply_and_increment(Block &block, NodeList<Statement>::iterator &i)
 128 {
 129         block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
 130         insert_nodes.clear();
 131
 132         if(remove_node)
 133                 block.body.erase(i++);
 134         else
 135                 ++i;
 136         remove_node = false;
 137 }
 138
 139 void BlockModifier::visit(Block &block)
 140 {
 141         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 142         {
 143                 (*i)->visit(*this);
 144                 apply_and_increment(block, i);
 145         }
 146 }
 147
 148
 149 NodeRemover::NodeRemover(const set<Node *> &r):
 150         stage(0),
 151         to_remove(r)
 152 { }
 153
 154 void NodeRemover::apply(Stage &s)
 155 {
 156         SetForScope<Stage *> set_stage(stage, &s);
 157         visit(s.content);
 158 }
 159
 160 void NodeRemover::visit(Block &block)
 161 {
 162         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 163         {
 164                 (*i)->visit(*this);
 165                 if(to_remove.count(i->get()))
 166                         block.body.erase(i++);
 167                 else
 168                         ++i;
 169         }
 170 }
 171
 172 void NodeRemover::visit(VariableDeclaration &var)
 173 {
 174         if(to_remove.count(&var))
 175         {
 176                 stage->in_variables.erase(var.name);
 177                 stage->out_variables.erase(var.name);
 178                 stage->locations.erase(var.name);
 179                 if(var.linked_declaration)
 180                         var.linked_declaration->linked_declaration = 0;
 181         }
 182         else if(var.init_expression && to_remove.count(var.init_expression.get()))
 183                 var.init_expression = 0;
 184 }
 185
 186 void NodeRemover::visit(Iteration &iter)
 187 {
 188         if(to_remove.count(iter.init_statement.get()))
 189                 iter.init_statement = 0;
 190         TraversingVisitor::visit(iter);
 191 }
 192
 193 } // namespace SL
 194 } // namespace GL
 195 } // namespace Msp