X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fvisitor.cpp;h=b0025982fc75255041187ef4d66ce58af5930997;hp=91e75b7006b40cf0d621e0a3498c5cf2e5431fe1;hb=38712d8ecc57d043a2419ffbaeeb57f7a6586f14;hpb=05597fbb3671dfed4776bc5223958c85e780345e diff --git a/source/glsl/visitor.cpp b/source/glsl/visitor.cpp index 91e75b70..b0025982 100644 --- a/source/glsl/visitor.cpp +++ b/source/glsl/visitor.cpp @@ -7,48 +7,63 @@ namespace Msp { namespace GL { namespace SL { -void NodeVisitor::visit(Assignment &assign) +void TraversingVisitor::visit(Block &block) { - visit(static_cast(assign)); + if(&block!=current_block) + enter(block); + SetForScope set_block(current_block, &block); + for(const RefPtr &s: block.body) + s->visit(*this); } - -void TraversingVisitor::visit(Block &block) +void TraversingVisitor::visit(RefPtr &expr) { - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) - (*i)->visit(*this); + expr->visit(*this); } -void TraversingVisitor::visit(ParenthesizedExpression &parexpr) +void TraversingVisitor::visit(MemberAccess &memacc) { - parexpr.expression->visit(*this); + visit(memacc.left); } -void TraversingVisitor::visit(MemberAccess &memacc) +void TraversingVisitor::visit(Swizzle &swizzle) { - memacc.left->visit(*this); + visit(swizzle.left); } void TraversingVisitor::visit(UnaryExpression &unary) { - unary.expression->visit(*this); + visit(unary.expression); } void TraversingVisitor::visit(BinaryExpression &binary) { - binary.left->visit(*this); - binary.right->visit(*this); + visit(binary.left); + visit(binary.right); +} + +void TraversingVisitor::visit(Assignment &assign) +{ + visit(assign.left); + visit(assign.right); +} + +void TraversingVisitor::visit(TernaryExpression &ternary) +{ + visit(ternary.condition); + visit(ternary.true_expr); + visit(ternary.false_expr); } void TraversingVisitor::visit(FunctionCall &call) { - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - (*i)->visit(*this); + for(RefPtr &a: call.arguments) + visit(a); } void TraversingVisitor::visit(ExpressionStatement &expr) { - expr.expression->visit(*this); + visit(expr.expression); } void TraversingVisitor::visit(InterfaceLayout &layout) @@ -66,130 +81,163 @@ void TraversingVisitor::visit(VariableDeclaration &var) if(var.layout) var.layout->visit(*this); if(var.init_expression) - var.init_expression->visit(*this); + visit(var.init_expression); if(var.array_size) - var.array_size->visit(*this); + visit(var.array_size); } void TraversingVisitor::visit(InterfaceBlock &iface) { - iface.members.visit(*this); + if(iface.layout) + iface.layout->visit(*this); + if(iface.members) + iface.members->visit(*this); } void TraversingVisitor::visit(FunctionDeclaration &func) { - for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) - (*i)->visit(*this); + enter(func.body); + SetForScope set_block(current_block, &func.body); + for(const RefPtr &p: func.parameters) + p->visit(*this); func.body.visit(*this); } void TraversingVisitor::visit(Conditional &cond) { - cond.condition->visit(*this); + visit(cond.condition); cond.body.visit(*this); cond.else_body.visit(*this); } void TraversingVisitor::visit(Iteration &iter) { + enter(iter.body); + SetForScope set_block(current_block, &iter.body); if(iter.init_statement) iter.init_statement->visit(*this); if(iter.condition) - iter.condition->visit(*this); - if(iter.loop_expression) - iter.loop_expression->visit(*this); + visit(iter.condition); iter.body.visit(*this); + if(iter.loop_expression) + visit(iter.loop_expression); } void TraversingVisitor::visit(Passthrough &pass) { if(pass.subscript) - pass.subscript->visit(*this); + visit(pass.subscript); } void TraversingVisitor::visit(Return &ret) { if(ret.expression) - ret.expression->visit(*this); -} - - -BlockModifier::BlockModifier(): - remove_node(false) -{ } - -void BlockModifier::flatten_block(Block &block) -{ - insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end()); - remove_node = true; + visit(ret.expression); } -void BlockModifier::apply_and_increment(Block &block, NodeList::iterator &i) -{ - block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); - insert_nodes.clear(); - - if(remove_node) - block.body.erase(i++); - else - ++i; - remove_node = false; -} -void BlockModifier::visit(Block &block) +void NodeRemover::apply(Stage &s, const set &tr) { - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) - { - (*i)->visit(*this); - apply_and_increment(block, i); - } + stage = &s; + to_remove = &tr; + s.content.visit(*this); } - -NodeRemover::NodeRemover(const set &r): - stage(0), - to_remove(r) -{ } - -void NodeRemover::apply(Stage &s) +template +void NodeRemover::remove_from_map(map &vars, const string &key, T &node) { - stage = &s; - visit(s.content); + auto i = vars.find(key); + if(i!=vars.end() && i->second==&node) + vars.erase(i); } void NodeRemover::visit(Block &block) { - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) + SetForScope set_block(current_block, &block); + for(auto i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); - if(to_remove.count(i->get())) + if(to_remove->count(i->get())) block.body.erase(i++); else ++i; } } +void NodeRemover::visit(TypeDeclaration &type) +{ + if(to_remove->count(&type)) + remove_from_map(stage->types, type.name, type); +} + void NodeRemover::visit(VariableDeclaration &var) { - if(to_remove.count(&var)) + if(recursive_remove || to_remove->count(&var)) { - stage->in_variables.erase(var.name); - stage->out_variables.erase(var.name); + remove_from_map(current_block->variables, var.name, var); stage->locations.erase(var.name); if(var.linked_declaration) var.linked_declaration->linked_declaration = 0; } - else if(var.init_expression && to_remove.count(var.init_expression.get())) + else if(var.init_expression && to_remove->count(var.init_expression.get())) var.init_expression = 0; } +void NodeRemover::visit(InterfaceBlock &iface) +{ + if(to_remove->count(&iface)) + { + remove_from_map(stage->interface_blocks, format("%s %s", iface.interface, iface.block_name), iface); + if(!iface.instance_name.empty()) + remove_from_map(stage->interface_blocks, iface.instance_name, iface); + } + SetFlag set_recursive(recursive_remove, recursive_remove || to_remove->count(&iface)); + TraversingVisitor::visit(iface); +} + +void NodeRemover::visit(FunctionDeclaration &func) +{ + if(to_remove->count(&func)) + { + remove_from_map(stage->functions, func.name, func); + if(!func.signature.empty()) + remove_from_map(stage->functions, func.name+func.signature, func); + } + TraversingVisitor::visit(func); +} + void NodeRemover::visit(Iteration &iter) { - if(to_remove.count(iter.init_statement.get())) + if(to_remove->count(iter.init_statement.get())) iter.init_statement = 0; TraversingVisitor::visit(iter); } + +void NodeReorderer::apply(Stage &stage, Node &before, const set &tr) +{ + reorder_before = &before; + to_reorder = &tr; + stage.content.visit(*this); +} + +void NodeReorderer::visit(Block &block) +{ + auto insert_point = block.body.end(); + for(auto i=block.body.begin(); i!=block.body.end(); ) + { + (*i)->visit(*this); + if(insert_point!=block.body.end() && to_reorder->count(i->get())) + block.body.splice(insert_point, block.body, i++); + else + { + if(i->get()==reorder_before) + insert_point = i; + ++i; + } + } +} + } // namespace SL } // namespace GL } // namespace Msp