X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fvisitor.cpp;h=bcd6051a7c4a65b13604a5e75ec63eeed9c8de7b;hp=c740d1188a15cf2f02614f19248ddd2a2c259e75;hb=HEAD;hpb=caa84a9d8adce6dc702f6e0ae32961b77a0a73ea diff --git a/source/glsl/visitor.cpp b/source/glsl/visitor.cpp index c740d118..bcd6051a 100644 --- a/source/glsl/visitor.cpp +++ b/source/glsl/visitor.cpp @@ -12,46 +12,58 @@ void TraversingVisitor::visit(Block &block) if(&block!=current_block) enter(block); SetForScope set_block(current_block, &block); - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) - (*i)->visit(*this); + for(const RefPtr &s: block.body) + s->visit(*this); } -void TraversingVisitor::visit(ParenthesizedExpression &parexpr) +void TraversingVisitor::visit(RefPtr &expr) { - parexpr.expression->visit(*this); + expr->visit(*this); } void TraversingVisitor::visit(MemberAccess &memacc) { - memacc.left->visit(*this); + visit(memacc.left); +} + +void TraversingVisitor::visit(Swizzle &swizzle) +{ + 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) { - assign.left->visit(*this); - assign.right->visit(*this); + 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) @@ -69,28 +81,23 @@ 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); -} - -void TraversingVisitor::visit(InterfaceBlock &iface) -{ - iface.members.visit(*this); + visit(var.array_size); } void TraversingVisitor::visit(FunctionDeclaration &func) { enter(func.body); SetForScope set_block(current_block, &func.body); - for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) - (*i)->visit(*this); + 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); } @@ -102,31 +109,25 @@ void TraversingVisitor::visit(Iteration &iter) if(iter.init_statement) iter.init_statement->visit(*this); if(iter.condition) - iter.condition->visit(*this); + visit(iter.condition); iter.body.visit(*this); if(iter.loop_expression) - iter.loop_expression->visit(*this); + 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); + visit(ret.expression); } -NodeRemover::NodeRemover(): - stage(0), - to_remove(0), - recursive_remove(false) -{ } - void NodeRemover::apply(Stage &s, const set &tr) { stage = &s; @@ -137,7 +138,7 @@ void NodeRemover::apply(Stage &s, const set &tr) template void NodeRemover::remove_from_map(map &vars, const string &key, T &node) { - typename map::iterator i = vars.find(key); + auto i = vars.find(key); if(i!=vars.end() && i->second==&node) vars.erase(i); } @@ -145,7 +146,7 @@ void NodeRemover::remove_from_map(map &vars, const string &key, T & void NodeRemover::visit(Block &block) { SetForScope set_block(current_block, &block); - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) + for(auto i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); if(to_remove->count(i->get())) @@ -161,11 +162,32 @@ void NodeRemover::visit(TypeDeclaration &type) remove_from_map(stage->types, type.name, type); } +void NodeRemover::visit(StructDeclaration &strct) +{ + if(to_remove->count(&strct)) + { + remove_from_map(stage->types, strct.name, strct); + if(strct.block_declaration) + { + string key = format("%s %s", strct.block_declaration->interface, strct.block_name); + remove_from_map(stage->interface_blocks, key, *strct.block_declaration); + remove_from_map(stage->interface_blocks, strct.block_declaration->name, *strct.block_declaration); + strct.block_declaration->block_declaration = 0; + } + } +} + void NodeRemover::visit(VariableDeclaration &var) { - if(recursive_remove || to_remove->count(&var)) + if(to_remove->count(&var)) { remove_from_map(current_block->variables, var.name, var); + if(var.block_declaration) + { + remove_from_map(stage->interface_blocks, format("%s %s", var.interface, var.block_declaration->block_name), var); + remove_from_map(stage->interface_blocks, var.name, var); + var.block_declaration->block_declaration = 0; + } stage->locations.erase(var.name); if(var.linked_declaration) var.linked_declaration->linked_declaration = 0; @@ -174,22 +196,14 @@ void NodeRemover::visit(VariableDeclaration &var) var.init_expression = 0; } -void NodeRemover::visit(InterfaceBlock &iface) -{ - if(to_remove->count(&iface)) - { - remove_from_map(stage->interface_blocks, iface.interface+iface.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); } @@ -201,11 +215,6 @@ void NodeRemover::visit(Iteration &iter) } -NodeReorderer::NodeReorderer(): - reorder_before(0), - to_reorder(0) -{ } - void NodeReorderer::apply(Stage &stage, Node &before, const set &tr) { reorder_before = &before; @@ -215,15 +224,12 @@ void NodeReorderer::apply(Stage &stage, Node &before, const set &tr) void NodeReorderer::visit(Block &block) { - NodeList::iterator insert_point = block.body.end(); - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) + 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())) - { - NodeList::iterator j = i++; - block.body.splice(insert_point, block.body, j); - } + block.body.splice(insert_point, block.body, i++); else { if(i->get()==reorder_before)