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 TraversingVisitor::visit(Block &block)
  11 {
  12         if(&block!=current_block)
  13                 enter(block);
  14         SetForScope<Block *> set_block(current_block, &block);
  15         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
  16                 (*i)->visit(*this);
  17 }
  18
  19 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
  20 {
  21         parexpr.expression->visit(*this);
  22 }
  23
  24 void TraversingVisitor::visit(MemberAccess &memacc)
  25 {
  26         memacc.left->visit(*this);
  27 }
  28
  29 void TraversingVisitor::visit(UnaryExpression &unary)
  30 {
  31         unary.expression->visit(*this);
  32 }
  33
  34 void TraversingVisitor::visit(BinaryExpression &binary)
  35 {
  36         binary.left->visit(*this);
  37         binary.right->visit(*this);
  38 }
  39
  40 void TraversingVisitor::visit(Assignment &assign)
  41 {
  42         assign.left->visit(*this);
  43         assign.right->visit(*this);
  44 }
  45
  46 void TraversingVisitor::visit(FunctionCall &call)
  47 {
  48         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
  49                 (*i)->visit(*this);
  50 }
  51
  52 void TraversingVisitor::visit(ExpressionStatement &expr)
  53 {
  54         expr.expression->visit(*this);
  55 }
  56
  57 void TraversingVisitor::visit(InterfaceLayout &layout)
  58 {
  59         layout.layout.visit(*this);
  60 }
  61
  62 void TraversingVisitor::visit(StructDeclaration &strct)
  63 {
  64         strct.members.visit(*this);
  65 }
  66
  67 void TraversingVisitor::visit(VariableDeclaration &var)
  68 {
  69         if(var.layout)
  70                 var.layout->visit(*this);
  71         if(var.init_expression)
  72                 var.init_expression->visit(*this);
  73         if(var.array_size)
  74                 var.array_size->visit(*this);
  75 }
  76
  77 void TraversingVisitor::visit(InterfaceBlock &iface)
  78 {
  79         if(iface.members)
  80                 iface.members->visit(*this);
  81 }
  82
  83 void TraversingVisitor::visit(FunctionDeclaration &func)
  84 {
  85         enter(func.body);
  86         SetForScope<Block *> set_block(current_block, &func.body);
  87         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
  88                 (*i)->visit(*this);
  89         func.body.visit(*this);
  90 }
  91
  92 void TraversingVisitor::visit(Conditional &cond)
  93 {
  94         cond.condition->visit(*this);
  95         cond.body.visit(*this);
  96         cond.else_body.visit(*this);
  97 }
  98
  99 void TraversingVisitor::visit(Iteration &iter)
 100 {
 101         enter(iter.body);
 102         SetForScope<Block *> set_block(current_block, &iter.body);
 103         if(iter.init_statement)
 104                 iter.init_statement->visit(*this);
 105         if(iter.condition)
 106                 iter.condition->visit(*this);
 107         iter.body.visit(*this);
 108         if(iter.loop_expression)
 109                 iter.loop_expression->visit(*this);
 110 }
 111
 112 void TraversingVisitor::visit(Passthrough &pass)
 113 {
 114         if(pass.subscript)
 115                 pass.subscript->visit(*this);
 116 }
 117
 118 void TraversingVisitor::visit(Return &ret)
 119 {
 120         if(ret.expression)
 121                 ret.expression->visit(*this);
 122 }
 123
 124
 125 NodeRemover::NodeRemover():
 126         stage(0),
 127         to_remove(0),
 128         recursive_remove(false)
 129 { }
 130
 131 void NodeRemover::apply(Stage &s, const set<Node *> &tr)
 132 {
 133         stage = &s;
 134         to_remove = &tr;
 135         s.content.visit(*this);
 136 }
 137
 138 template<typename T>
 139 void NodeRemover::remove_from_map(map<string, T *> &vars, const string &key, T &node)
 140 {
 141         typename map<string, T *>::iterator i = vars.find(key);
 142         if(i!=vars.end() && i->second==&node)
 143                 vars.erase(i);
 144 }
 145
 146 void NodeRemover::visit(Block &block)
 147 {
 148         SetForScope<Block *> set_block(current_block, &block);
 149         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 150         {
 151                 (*i)->visit(*this);
 152                 if(to_remove->count(i->get()))
 153                         block.body.erase(i++);
 154                 else
 155                         ++i;
 156         }
 157 }
 158
 159 void NodeRemover::visit(TypeDeclaration &type)
 160 {
 161         if(to_remove->count(&type))
 162                 remove_from_map(stage->types, type.name, type);
 163 }
 164
 165 void NodeRemover::visit(VariableDeclaration &var)
 166 {
 167         if(recursive_remove || to_remove->count(&var))
 168         {
 169                 remove_from_map(current_block->variables, var.name, var);
 170                 stage->locations.erase(var.name);
 171                 if(var.linked_declaration)
 172                         var.linked_declaration->linked_declaration = 0;
 173         }
 174         else if(var.init_expression && to_remove->count(var.init_expression.get()))
 175                 var.init_expression = 0;
 176 }
 177
 178 void NodeRemover::visit(InterfaceBlock &iface)
 179 {
 180         if(to_remove->count(&iface))
 181         {
 182                 remove_from_map(stage->interface_blocks, iface.interface+iface.name, iface);
 183                 if(!iface.instance_name.empty())
 184                         remove_from_map(stage->interface_blocks, "_"+iface.instance_name, iface);
 185         }
 186         SetFlag set_recursive(recursive_remove, recursive_remove || to_remove->count(&iface));
 187         TraversingVisitor::visit(iface);
 188 }
 189
 190 void NodeRemover::visit(FunctionDeclaration &func)
 191 {
 192         if(to_remove->count(&func))
 193                 remove_from_map(stage->functions, func.name, func);
 194         TraversingVisitor::visit(func);
 195 }
 196
 197 void NodeRemover::visit(Iteration &iter)
 198 {
 199         if(to_remove->count(iter.init_statement.get()))
 200                 iter.init_statement = 0;
 201         TraversingVisitor::visit(iter);
 202 }
 203
 204
 205 NodeReorderer::NodeReorderer():
 206         reorder_before(0),
 207         to_reorder(0)
 208 { }
 209
 210 void NodeReorderer::apply(Stage &stage, Node &before, const set<Node *> &tr)
 211 {
 212         reorder_before = &before;
 213         to_reorder = &tr;
 214         stage.content.visit(*this);
 215 }
 216
 217 void NodeReorderer::visit(Block &block)
 218 {
 219         NodeList<Statement>::iterator insert_point = block.body.end();
 220         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
 221         {
 222                 (*i)->visit(*this);
 223                 if(insert_point!=block.body.end() && to_reorder->count(i->get()))
 224                 {
 225                         NodeList<Statement>::iterator j = i++;
 226                         block.body.splice(insert_point, block.body, j);
 227                 }
 228                 else
 229                 {
 230                         if(i->get()==reorder_before)
 231                                 insert_point = i;
 232                         ++i;
 233                 }
 234         }
 235 }
 236
 237 } // namespace SL
 238 } // namespace GL
 239 } // namespace Msp