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