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