]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/syntax.cpp
Set color write mask if no blending is used
[libs/gl.git] / source / glsl / syntax.cpp
1 #include <msp/core/algorithm.h>
2 #include <msp/core/maputils.h>
3 #include "syntax.h"
4 #include "visitor.h"
5
6 using namespace std;
7
8 namespace Msp {
9 namespace GL {
10 namespace SL {
11
12 const Operator Operator::operators[] =
13 {
14         { "[", "]", 2, BINARY, LEFT_TO_RIGHT },
15         { "(", ")", 2, POSTFIX, LEFT_TO_RIGHT },
16         { ".", { }, 2, POSTFIX, LEFT_TO_RIGHT },
17         { "++", { }, 2, POSTFIX, LEFT_TO_RIGHT },
18         { "--", { }, 2, POSTFIX, LEFT_TO_RIGHT },
19         { "++", { }, 3, PREFIX, RIGHT_TO_LEFT },
20         { "--", { }, 3, PREFIX, RIGHT_TO_LEFT },
21         { "+", { }, 3, PREFIX, RIGHT_TO_LEFT },
22         { "-", { }, 3, PREFIX, RIGHT_TO_LEFT },
23         { "~", { }, 3, PREFIX, RIGHT_TO_LEFT },
24         { "!", { }, 3, PREFIX, RIGHT_TO_LEFT },
25         { "*", { }, 4, BINARY, ASSOCIATIVE },
26         { "/", { }, 4, BINARY, LEFT_TO_RIGHT },
27         { "%", { }, 4, BINARY, LEFT_TO_RIGHT },
28         { "+", { }, 5, BINARY, ASSOCIATIVE },
29         { "-", { }, 5, BINARY, LEFT_TO_RIGHT },
30         { "<<", { }, 6, BINARY, LEFT_TO_RIGHT },
31         { ">>", { }, 6, BINARY, LEFT_TO_RIGHT },
32         { "<", { }, 7, BINARY, LEFT_TO_RIGHT },
33         { ">", { }, 7, BINARY, LEFT_TO_RIGHT },
34         { "<=", { }, 7, BINARY, LEFT_TO_RIGHT },
35         { ">=", { }, 7, BINARY, LEFT_TO_RIGHT },
36         { "==", { }, 8, BINARY, LEFT_TO_RIGHT },
37         { "!=", { }, 8, BINARY, LEFT_TO_RIGHT },
38         { "&", { }, 9, BINARY, ASSOCIATIVE },
39         { "^", { }, 10, BINARY, ASSOCIATIVE },
40         { "|", { }, 11, BINARY, ASSOCIATIVE },
41         { "&&", { }, 12, BINARY, ASSOCIATIVE },
42         { "^^", { }, 13, BINARY, ASSOCIATIVE },
43         { "||", { }, 14, BINARY, ASSOCIATIVE },
44         { "?", ":", 15, TERNARY, RIGHT_TO_LEFT },
45         { "=", { }, 16, BINARY, RIGHT_TO_LEFT },
46         { "+=", { }, 16, BINARY, RIGHT_TO_LEFT },
47         { "-=", { }, 16, BINARY, RIGHT_TO_LEFT },
48         { "*=", { }, 16, BINARY, RIGHT_TO_LEFT },
49         { "/=", { }, 16, BINARY, RIGHT_TO_LEFT },
50         { "%=", { }, 16, BINARY, RIGHT_TO_LEFT },
51         { "<<=", { }, 16, BINARY, RIGHT_TO_LEFT },
52         { ">>=", { }, 16, BINARY, RIGHT_TO_LEFT },
53         { "&=", { }, 16, BINARY, RIGHT_TO_LEFT },
54         { "^=", { }, 16, BINARY, RIGHT_TO_LEFT },
55         { "|=", { }, 16, BINARY, RIGHT_TO_LEFT },
56         { ",", { }, 17, BINARY, LEFT_TO_RIGHT },
57         { { 0 }, { }, 18, NO_OPERATOR, LEFT_TO_RIGHT }
58 };
59
60 const Operator &Operator::get_operator(const string &token, Type type)
61 {
62         for(const Operator *i=operators; i->type; ++i)
63                 if(i->type==type && i->token==token)
64                         return *i;
65         throw key_error(token);
66 }
67
68
69 template<typename C>
70 NodeContainer<C>::NodeContainer(const NodeContainer &c):
71         C(c)
72 {
73         for(auto &i: *this)
74                 i = i->clone();
75 }
76
77
78 Block::Block(const Block &other):
79         Node(other),
80         body(other.body),
81         use_braces(other.use_braces)
82 { }
83
84 void Block::visit(NodeVisitor &visitor)
85 {
86         visitor.visit(*this);
87 }
88
89
90 void Literal::visit(NodeVisitor &visitor)
91 {
92         visitor.visit(*this);
93 }
94
95
96 VariableReference::VariableReference(const VariableReference &other):
97         Expression(other),
98         name(other.name)
99 { }
100
101 void VariableReference::visit(NodeVisitor &visitor)
102 {
103         visitor.visit(*this);
104 }
105
106
107 InterfaceBlockReference::InterfaceBlockReference(const InterfaceBlockReference &other):
108         Expression(other),
109         name(other.name)
110 { }
111
112 void InterfaceBlockReference::visit(NodeVisitor &visitor)
113 {
114         visitor.visit(*this);
115 }
116
117
118 MemberAccess::MemberAccess(const MemberAccess &other):
119         Expression(other),
120         left(other.left),
121         member(other.member)
122         // Do not copy declaration
123 { }
124
125 void MemberAccess::visit(NodeVisitor &visitor)
126 {
127         visitor.visit(*this);
128 }
129
130
131 void Swizzle::visit(NodeVisitor &visitor)
132 {
133         visitor.visit(*this);
134 }
135
136
137 void UnaryExpression::visit(NodeVisitor &visitor)
138 {
139         visitor.visit(*this);
140 }
141
142
143 void BinaryExpression::visit(NodeVisitor &visitor)
144 {
145         visitor.visit(*this);
146 }
147
148
149 Assignment::Assignment(const Assignment &other):
150         BinaryExpression(other),
151         self_referencing(other.self_referencing)
152         // Do not copy target
153 { }
154
155 void Assignment::visit(NodeVisitor &visitor)
156 {
157         visitor.visit(*this);
158 }
159
160
161 bool Assignment::Target::operator<(const Target &other) const
162 {
163         if(declaration!=other.declaration)
164                 return declaration<other.declaration;
165         for(unsigned i=0; (i<7 && i<chain_len && i<other.chain_len); ++i)
166                 if(chain[i]!=other.chain[i])
167                         return chain[i]<other.chain[i];
168         return chain_len<other.chain_len;
169 }
170
171
172 void TernaryExpression::visit(NodeVisitor &visitor)
173 {
174         visitor.visit(*this);
175 }
176
177
178 FunctionCall::FunctionCall(const FunctionCall &other):
179         Expression(other),
180         name(other.name),
181         constructor(other.constructor),
182         arguments(other.arguments)
183         // Do not copy declaration
184 { }
185
186 void FunctionCall::visit(NodeVisitor &visitor)
187 {
188         visitor.visit(*this);
189 }
190
191
192 void ExpressionStatement::visit(NodeVisitor &visitor)
193 {
194         visitor.visit(*this);
195 }
196
197
198 void Import::visit(NodeVisitor &visitor)
199 {
200         visitor.visit(*this);
201 }
202
203
204 void Precision::visit(NodeVisitor &visitor)
205 {
206         visitor.visit(*this);
207 }
208
209
210 void Layout::visit(NodeVisitor &visitor)
211 {
212         visitor.visit(*this);
213 }
214
215
216 void InterfaceLayout::visit(NodeVisitor &visitor)
217 {
218         visitor.visit(*this);
219 }
220
221
222 BasicTypeDeclaration::BasicTypeDeclaration(const BasicTypeDeclaration &other):
223         TypeDeclaration(other),
224         kind(other.kind),
225         size(other.size),
226         sign(other.sign),
227         base(other.base)
228         // Do not copy base type
229 { }
230
231 void BasicTypeDeclaration::visit(NodeVisitor &visitor)
232 {
233         visitor.visit(*this);
234 }
235
236
237 void ImageTypeDeclaration::visit(NodeVisitor &visitor)
238 {
239         visitor.visit(*this);
240 }
241
242
243 StructDeclaration::StructDeclaration()
244 {
245         members.use_braces = true;
246 }
247
248 StructDeclaration::StructDeclaration(const StructDeclaration &other):
249         TypeDeclaration(other),
250         members(other.members)
251         // Do not copy interface block
252 { }
253
254 StructDeclaration::~StructDeclaration()
255 {
256         if(interface_block && interface_block->struct_declaration==this)
257                 interface_block->struct_declaration = 0;
258 }
259
260 void StructDeclaration::visit(NodeVisitor &visitor)
261 {
262         visitor.visit(*this);
263 }
264
265
266 VariableDeclaration::VariableDeclaration(const VariableDeclaration &other):
267         Statement(other),
268         layout(other.layout),
269         constant(other.constant),
270         sampling(other.sampling),
271         interpolation(other.interpolation),
272         interface(other.interface),
273         precision(other.precision),
274         type(other.type),
275         name(other.name),
276         array(other.array),
277         array_size(other.array_size),
278         init_expression(other.init_expression)
279         // Do not copy type and linked declarations
280 { }
281
282 VariableDeclaration::~VariableDeclaration()
283 {
284         if(linked_declaration && linked_declaration->linked_declaration==this)
285                 linked_declaration->linked_declaration = 0;
286 }
287
288 void VariableDeclaration::visit(NodeVisitor &visitor)
289 {
290         visitor.visit(*this);
291 }
292
293
294 InterfaceBlock::InterfaceBlock(const InterfaceBlock &other):
295         Statement(other),
296         layout(other.layout),
297         interface(other.interface),
298         block_name(other.block_name),
299         members(other.members),
300         instance_name(other.instance_name),
301         array(other.array)
302         // Do not copy pointers to other nodes
303 { }
304
305 InterfaceBlock::~InterfaceBlock()
306 {
307         if(linked_block && linked_block->linked_block==this)
308                 linked_block->linked_block = 0;
309         if(struct_declaration && struct_declaration->interface_block==this)
310                 struct_declaration->interface_block = 0;
311 }
312
313 void InterfaceBlock::visit(NodeVisitor &visitor)
314 {
315         visitor.visit(*this);
316 }
317
318
319 FunctionDeclaration::FunctionDeclaration(const FunctionDeclaration &other):
320         Statement(other),
321         return_type(other.return_type),
322         name(other.name),
323         parameters(other.parameters),
324         virtua(other.virtua),
325         overrd(other.overrd),
326         body(other.body),
327         signature(other.signature),
328         definition(other.definition==&other ? this : 0)
329         // Do not copy return type declaration
330 { }
331
332 void FunctionDeclaration::visit(NodeVisitor &visitor)
333 {
334         visitor.visit(*this);
335 }
336
337
338 void Conditional::visit(NodeVisitor &visitor)
339 {
340         visitor.visit(*this);
341 }
342
343
344 void Iteration::visit(NodeVisitor &visitor)
345 {
346         visitor.visit(*this);
347 }
348
349
350 void Passthrough::visit(NodeVisitor &visitor)
351 {
352         visitor.visit(*this);
353 }
354
355
356 void Return::visit(NodeVisitor &visitor)
357 {
358         visitor.visit(*this);
359 }
360
361
362 void Jump::visit(NodeVisitor &visitor)
363 {
364         visitor.visit(*this);
365 }
366
367
368 Stage::Stage(Stage::Type t):
369         type(t)
370 { }
371
372 const char *Stage::get_stage_name(Type type)
373 {
374         static const char *const names[] = { "shared", "vertex", "geometry", "fragment" };
375         return names[type];
376 }
377
378
379 Module::Module():
380         shared(Stage::SHARED)
381 { }
382
383
384 string get_unused_variable_name(const Block &block, const string &base)
385 {
386         string name = base;
387
388         unsigned number = 1;
389         unsigned base_size = name.size();
390         while(1)
391         {
392                 bool unused = true;
393                 for(const Block *b=&block; (unused && b); b=b->parent)
394                         unused = !b->variables.count(name);
395                 if(unused)
396                         return name;
397
398                 name.erase(base_size);
399                 name += format("_%d", number);
400                 ++number;
401         }
402 }
403
404 const TypeDeclaration *get_ultimate_base_type(const TypeDeclaration *type)
405 {
406         if(!type)
407                 return 0;
408         while(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
409         {
410                 if(!basic->base_type)
411                         break;
412                 type = basic->base_type;
413         }
414         return type;
415 }
416
417 bool has_layout_qualifier(const Layout *layout, const string &name)
418 {
419         if(!layout)
420                 return false;
421         auto i = find_member(layout->qualifiers, name, &Layout::Qualifier::name);
422         return i!=layout->qualifiers.end();
423 }
424
425 int get_layout_value(const Layout *layout, const string &name, int def_value)
426 {
427         if(!layout)
428                 return def_value;
429         auto i = find_member(layout->qualifiers, name, &Layout::Qualifier::name);
430         return (i!=layout->qualifiers.end() ? i->value : def_value);
431 }
432
433 void add_layout_qualifier(RefPtr<Layout> &layout, const Layout::Qualifier &q)
434 {
435         if(!layout)
436                 layout = new Layout;
437         layout->qualifiers.push_back(q);
438 }
439
440 void add_to_chain(Assignment::Target &target, Assignment::Target::ChainType type, unsigned index)
441 {
442         if(target.chain_len<7)
443                 target.chain[target.chain_len] = type | min<unsigned>(index, 0x3F);
444         ++target.chain_len;
445 }
446
447 bool targets_overlap(const Assignment::Target &target1, const Assignment::Target &target2)
448 {
449         bool overlap = (target1.declaration==target2.declaration);
450         for(unsigned i=0; (overlap && i<target1.chain_len && i<target2.chain_len); ++i)
451         {
452                 Assignment::Target::ChainType type1 = static_cast<Assignment::Target::ChainType>(target1.chain[i]&0xC0);
453                 Assignment::Target::ChainType type2 = static_cast<Assignment::Target::ChainType>(target2.chain[i]&0xC0);
454                 unsigned index1 = target1.chain[i]&0x3F;
455                 unsigned index2 = target2.chain[i]&0x3F;
456                 if(type1==Assignment::Target::SWIZZLE || type2==Assignment::Target::SWIZZLE)
457                 {
458                         if(type1==Assignment::Target::SWIZZLE && type2==Assignment::Target::SWIZZLE)
459                                 overlap = index1&index2;
460                         else if(type1==Assignment::Target::ARRAY && index1<4)
461                                 overlap = index2&(1<<index1);
462                         else if(type2==Assignment::Target::ARRAY && index2<4)
463                                 overlap = index1&(1<<index2);
464                         // Treat other combinations as overlapping (shouldn't happen)
465                 }
466                 else
467                         overlap = (type1==type2 && (index1==index2 || index1==0x3F || index2==0x3F));
468         }
469
470         return overlap;
471 }
472
473 } // namespace SL
474 } // namespace GL
475 } // namespace Msp