]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/visitor.cpp
Remove unused constructors
[libs/gl.git] / 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 NodeVisitor::visit(Assignment &assign)
11 {
12         visit(static_cast<BinaryExpression &>(assign));
13 }
14
15
16 void TraversingVisitor::visit(Block &block)
17 {
18         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
19                 (*i)->visit(*this);
20 }
21
22 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
23 {
24         parexpr.expression->visit(*this);
25 }
26
27 void TraversingVisitor::visit(MemberAccess &memacc)
28 {
29         memacc.left->visit(*this);
30 }
31
32 void TraversingVisitor::visit(UnaryExpression &unary)
33 {
34         unary.expression->visit(*this);
35 }
36
37 void TraversingVisitor::visit(BinaryExpression &binary)
38 {
39         binary.left->visit(*this);
40         binary.right->visit(*this);
41 }
42
43 void TraversingVisitor::visit(FunctionCall &call)
44 {
45         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
46                 (*i)->visit(*this);
47 }
48
49 void TraversingVisitor::visit(ExpressionStatement &expr)
50 {
51         expr.expression->visit(*this);
52 }
53
54 void TraversingVisitor::visit(InterfaceLayout &layout)
55 {
56         layout.layout.visit(*this);
57 }
58
59 void TraversingVisitor::visit(StructDeclaration &strct)
60 {
61         strct.members.visit(*this);
62 }
63
64 void TraversingVisitor::visit(VariableDeclaration &var)
65 {
66         if(var.layout)
67                 var.layout->visit(*this);
68         if(var.init_expression)
69                 var.init_expression->visit(*this);
70         if(var.array_size)
71                 var.array_size->visit(*this);
72 }
73
74 void TraversingVisitor::visit(InterfaceBlock &iface)
75 {
76         iface.members.visit(*this);
77 }
78
79 void TraversingVisitor::visit(FunctionDeclaration &func)
80 {
81         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
82                 (*i)->visit(*this);
83         func.body.visit(*this);
84 }
85
86 void TraversingVisitor::visit(Conditional &cond)
87 {
88         cond.condition->visit(*this);
89         cond.body.visit(*this);
90         cond.else_body.visit(*this);
91 }
92
93 void TraversingVisitor::visit(Iteration &iter)
94 {
95         if(iter.init_statement)
96                 iter.init_statement->visit(*this);
97         if(iter.condition)
98                 iter.condition->visit(*this);
99         if(iter.loop_expression)
100                 iter.loop_expression->visit(*this);
101         iter.body.visit(*this);
102 }
103
104 void TraversingVisitor::visit(Passthrough &pass)
105 {
106         if(pass.subscript)
107                 pass.subscript->visit(*this);
108 }
109
110 void TraversingVisitor::visit(Return &ret)
111 {
112         if(ret.expression)
113                 ret.expression->visit(*this);
114 }
115
116
117 BlockModifier::BlockModifier():
118         remove_node(false)
119 { }
120
121 void BlockModifier::flatten_block(Block &block)
122 {
123         insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
124         remove_node = true;
125 }
126
127 void BlockModifier::apply_and_increment(Block &block, NodeList<Statement>::iterator &i)
128 {
129         block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
130         insert_nodes.clear();
131
132         if(remove_node)
133                 block.body.erase(i++);
134         else
135                 ++i;
136         remove_node = false;
137 }
138
139 void BlockModifier::visit(Block &block)
140 {
141         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
142         {
143                 (*i)->visit(*this);
144                 apply_and_increment(block, i);
145         }
146 }
147
148
149 NodeRemover::NodeRemover(const set<Node *> &r):
150         stage(0),
151         to_remove(r)
152 { }
153
154 void NodeRemover::apply(Stage &s)
155 {
156         SetForScope<Stage *> set_stage(stage, &s);
157         visit(s.content);
158 }
159
160 void NodeRemover::visit(Block &block)
161 {
162         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); )
163         {
164                 (*i)->visit(*this);
165                 if(to_remove.count(i->get()))
166                         block.body.erase(i++);
167                 else
168                         ++i;
169         }
170 }
171
172 void NodeRemover::visit(VariableDeclaration &var)
173 {
174         if(to_remove.count(&var))
175         {
176                 stage->in_variables.erase(var.name);
177                 stage->out_variables.erase(var.name);
178                 stage->locations.erase(var.name);
179                 if(var.linked_declaration)
180                         var.linked_declaration->linked_declaration = 0;
181         }
182         else if(var.init_expression && to_remove.count(var.init_expression.get()))
183                 var.init_expression = 0;
184 }
185
186 void NodeRemover::visit(Iteration &iter)
187 {
188         if(to_remove.count(iter.init_statement.get()))
189                 iter.init_statement = 0;
190         TraversingVisitor::visit(iter);
191 }
192
193 } // namespace SL
194 } // namespace GL
195 } // namespace Msp