]> git.tdb.fi Git - libs/gl.git/blob - source/programsyntax.cpp
Further refactor Bufferable's API for derived classes
[libs/gl.git] / source / programsyntax.cpp
1 #include "programsyntax.h"
2
3 using namespace std;
4
5 namespace Msp {
6 namespace GL {
7 namespace ProgramSyntax {
8
9 template<typename C>
10 NodeContainer<C>::NodeContainer(const NodeContainer &c):
11         C(c)
12 {
13         for(typename C::iterator i=this->begin(); i!=this->end(); ++i)
14                 *i = (*i)->clone();
15 }
16
17
18 Statement::Statement():
19         source(0),
20         line(1)
21 { }
22
23
24 Block::Block():
25         use_braces(false)
26 { }
27
28 void Block::visit(NodeVisitor &visitor)
29 {
30         visitor.visit(*this);
31 }
32
33
34 void Literal::visit(NodeVisitor &visitor)
35 {
36         visitor.visit(*this);
37 }
38
39
40 void ParenthesizedExpression::visit(NodeVisitor &visitor)
41 {
42         visitor.visit(*this);
43 }
44
45
46 VariableReference::VariableReference():
47         declaration(0)
48 { }
49
50 void VariableReference::visit(NodeVisitor &visitor)
51 {
52         visitor.visit(*this);
53 }
54
55
56 void MemberAccess::visit(NodeVisitor &visitor)
57 {
58         visitor.visit(*this);
59 }
60
61
62 UnaryExpression::UnaryExpression():
63         prefix(true)
64 { }
65
66 void UnaryExpression::visit(NodeVisitor &visitor)
67 {
68         visitor.visit(*this);
69 }
70
71
72 void BinaryExpression::visit(NodeVisitor &visitor)
73 {
74         visitor.visit(*this);
75 }
76
77
78 Assignment::Assignment():
79         self_referencing(false),
80         target_declaration(0)
81 { }
82
83 void Assignment::visit(NodeVisitor &visitor)
84 {
85         visitor.visit(*this);
86 }
87
88
89 FunctionCall::FunctionCall():
90         declaration(0),
91         constructor(false)
92 { }
93
94 void FunctionCall::visit(NodeVisitor &visitor)
95 {
96         visitor.visit(*this);
97 }
98
99
100 void ExpressionStatement::visit(NodeVisitor &visitor)
101 {
102         visitor.visit(*this);
103 }
104
105
106 void Import::visit(NodeVisitor &visitor)
107 {
108         visitor.visit(*this);
109 }
110
111
112 void Precision::visit(NodeVisitor &visitor)
113 {
114         visitor.visit(*this);
115 }
116
117
118 void Layout::visit(NodeVisitor &visitor)
119 {
120         visitor.visit(*this);
121 }
122
123
124 void InterfaceLayout::visit(NodeVisitor &visitor)
125 {
126         visitor.visit(*this);
127 }
128
129
130 StructDeclaration::StructDeclaration()
131 {
132         members.use_braces = true;
133 }
134
135 void StructDeclaration::visit(NodeVisitor &visitor)
136 {
137         visitor.visit(*this);
138 }
139
140
141 VariableDeclaration::VariableDeclaration():
142         constant(false),
143         type_declaration(0),
144         array(false),
145         linked_declaration(0)
146 { }
147
148 void VariableDeclaration::visit(NodeVisitor &visitor)
149 {
150         visitor.visit(*this);
151 }
152
153
154 InterfaceBlock::InterfaceBlock():
155         array(false)
156 {
157         members.use_braces = true;
158 }
159
160 void InterfaceBlock::visit(NodeVisitor &visitor)
161 {
162         visitor.visit(*this);
163 }
164
165
166 FunctionDeclaration::FunctionDeclaration():
167         definition(0)
168 { }
169
170 FunctionDeclaration::FunctionDeclaration(const FunctionDeclaration &other):
171         return_type(other.return_type),
172         name(other.name),
173         parameters(other.parameters),
174         definition(other.definition==&other ? this : other.definition),
175         body(other.body)
176 { }
177
178 void FunctionDeclaration::visit(NodeVisitor &visitor)
179 {
180         visitor.visit(*this);
181 }
182
183
184 void Conditional::visit(NodeVisitor &visitor)
185 {
186         visitor.visit(*this);
187 }
188
189
190 void Iteration::visit(NodeVisitor &visitor)
191 {
192         visitor.visit(*this);
193 }
194
195
196 void Passthrough::visit(NodeVisitor &visitor)
197 {
198         visitor.visit(*this);
199 }
200
201
202 void Return::visit(NodeVisitor &visitor)
203 {
204         visitor.visit(*this);
205 }
206
207
208 void Jump::visit(NodeVisitor &visitor)
209 {
210         visitor.visit(*this);
211 }
212
213
214 void NodeVisitor::visit(Assignment &assign)
215 {
216         visit(static_cast<BinaryExpression &>(assign));
217 }
218
219
220 void TraversingVisitor::visit(Block &block)
221 {
222         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
223                 (*i)->visit(*this);
224 }
225
226 void TraversingVisitor::visit(ParenthesizedExpression &parexpr)
227 {
228         parexpr.expression->visit(*this);
229 }
230
231 void TraversingVisitor::visit(MemberAccess &memacc)
232 {
233         memacc.left->visit(*this);
234 }
235
236 void TraversingVisitor::visit(UnaryExpression &unary)
237 {
238         unary.expression->visit(*this);
239 }
240
241 void TraversingVisitor::visit(BinaryExpression &binary)
242 {
243         binary.left->visit(*this);
244         binary.right->visit(*this);
245 }
246
247 void TraversingVisitor::visit(FunctionCall &call)
248 {
249         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
250                 (*i)->visit(*this);
251 }
252
253 void TraversingVisitor::visit(ExpressionStatement &expr)
254 {
255         expr.expression->visit(*this);
256 }
257
258 void TraversingVisitor::visit(InterfaceLayout &layout)
259 {
260         layout.layout.visit(*this);
261 }
262
263 void TraversingVisitor::visit(StructDeclaration &strct)
264 {
265         strct.members.visit(*this);
266 }
267
268 void TraversingVisitor::visit(VariableDeclaration &var)
269 {
270         if(var.layout)
271                 var.layout->visit(*this);
272         if(var.init_expression)
273                 var.init_expression->visit(*this);
274         if(var.array_size)
275                 var.array_size->visit(*this);
276 }
277
278 void TraversingVisitor::visit(InterfaceBlock &iface)
279 {
280         iface.members.visit(*this);
281 }
282
283 void TraversingVisitor::visit(FunctionDeclaration &func)
284 {
285         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
286                 (*i)->visit(*this);
287         func.body.visit(*this);
288 }
289
290 void TraversingVisitor::visit(Conditional &cond)
291 {
292         cond.condition->visit(*this);
293         cond.body.visit(*this);
294         cond.else_body.visit(*this);
295 }
296
297 void TraversingVisitor::visit(Iteration &iter)
298 {
299         if(iter.init_statement)
300                 iter.init_statement->visit(*this);
301         if(iter.condition)
302                 iter.condition->visit(*this);
303         if(iter.loop_expression)
304                 iter.loop_expression->visit(*this);
305         iter.body.visit(*this);
306 }
307
308 void TraversingVisitor::visit(Passthrough &pass)
309 {
310         if(pass.subscript)
311                 pass.subscript->visit(*this);
312 }
313
314 void TraversingVisitor::visit(Return &ret)
315 {
316         if(ret.expression)
317                 ret.expression->visit(*this);
318 }
319
320
321 Stage::Stage(StageType t):
322         type(t),
323         previous(0)
324 { }
325
326
327 Module::Module():
328         shared(SHARED)
329 { }
330
331 } // namespace ProgramSyntax
332 } // namespace GL
333 } // namespace Msp