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