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