]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/syntax.h
Redesign framebuffer attachment management
[libs/gl.git] / source / glsl / syntax.h
1 #ifndef MSP_GL_SL_SYNTAX_H_
2 #define MSP_GL_SL_SYNTAX_H_
3
4 #include <list>
5 #include <map>
6 #include <set>
7 #include <string>
8 #include <vector>
9 #include <msp/core/inttypes.h>
10 #include <msp/core/refptr.h>
11 #include <msp/core/variant.h>
12 #include "features.h"
13 #include "glsl_error.h"
14 #include "sourcemap.h"
15
16 #pragma push_macro("interface")
17 #undef interface
18
19 namespace Msp {
20 namespace GL {
21 namespace SL {
22
23 struct Operator
24 {
25         enum Type
26         {
27                 NO_OPERATOR,
28                 BINARY,
29                 PREFIX,
30                 POSTFIX,
31                 TERNARY
32         };
33
34         enum Associativity
35         {
36                 LEFT_TO_RIGHT,
37                 RIGHT_TO_LEFT,
38                 ASSOCIATIVE
39         };
40
41         char token[4];
42         char token2[2];
43         UInt8 precedence;
44         Type type;
45         Associativity assoc;
46
47         static const Operator operators[];
48
49         static const Operator &get_operator(const std::string &, Type);
50 };
51
52 enum
53 {
54         INTERNAL_SOURCE = -2,
55         BUILTIN_SOURCE = -1,
56         GENERATED_SOURCE = 0
57 };
58
59 struct NodeVisitor;
60
61 struct Node
62 {
63         int source;
64         unsigned line;
65
66         Node(): source(GENERATED_SOURCE), line(1) { }
67         Node(const Node &n): source(n.source), line(n.line) { }
68 private:
69         Node &operator=(const Node &);
70 public:
71         virtual ~Node() { }
72
73         virtual Node *clone() const = 0;
74         virtual void visit(NodeVisitor &) = 0;
75 };
76
77 template<typename T>
78 class NodePtr: public RefPtr<T>
79 {
80 public:
81         NodePtr() { }
82         NodePtr(T *p): RefPtr<T>(p) { }
83         NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
84         NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
85
86         template<typename U>
87         NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
88
89         template<typename U>
90         NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
91 };
92
93 template<typename C>
94 class NodeContainer: public C
95 {
96 public:
97         NodeContainer() { }
98         NodeContainer(const NodeContainer &);
99
100         void push_back_nocopy(const typename C::value_type &v)
101         { C::push_back(0); C::back() = v; }
102 };
103
104 template<typename T>
105 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
106 { };
107
108 template<typename T>
109 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
110 { };
111
112 struct TypeDeclaration;
113 struct VariableDeclaration;
114 struct InterfaceBlock;
115 struct FunctionDeclaration;
116
117 struct Statement: Node
118 {
119         virtual Statement *clone() const = 0;
120 };
121
122 struct Block: Node
123 {
124         NodeList<Statement> body;
125         bool use_braces;
126
127         std::map<std::string, VariableDeclaration *> variables;
128         Block *parent;
129
130         Block();
131         Block(const Block &);
132
133         virtual Block *clone() const { return new Block(*this); }
134         virtual void visit(NodeVisitor &);
135 };
136
137 struct Expression: Node
138 {
139         const Operator *oper;
140
141         TypeDeclaration *type;
142         bool lvalue;
143
144         Expression();
145
146         virtual Expression *clone() const = 0;
147 };
148
149 struct Literal: Expression
150 {
151         std::string token;
152         Variant value;
153
154         virtual Literal *clone() const { return new Literal(*this); }
155         virtual void visit(NodeVisitor &);
156 };
157
158 struct VariableReference: Expression
159 {
160         std::string name;
161
162         VariableDeclaration *declaration;
163
164         VariableReference();
165         VariableReference(const VariableReference &);
166
167         virtual VariableReference *clone() const { return new VariableReference(*this); }
168         virtual void visit(NodeVisitor &);
169 };
170
171 struct InterfaceBlockReference: Expression
172 {
173         std::string name;
174
175         InterfaceBlock *declaration;
176
177         InterfaceBlockReference();
178         InterfaceBlockReference(const InterfaceBlockReference &);
179
180         virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
181         virtual void visit(NodeVisitor &);
182 };
183
184 struct MemberAccess: Expression
185 {
186         NodePtr<Expression> left;
187         std::string member;
188
189         VariableDeclaration *declaration;
190         int index;
191
192         MemberAccess();
193         MemberAccess(const MemberAccess &);
194
195         virtual MemberAccess *clone() const { return new MemberAccess(*this); }
196         virtual void visit(NodeVisitor &);
197 };
198
199 struct Swizzle: Expression
200 {
201         NodePtr<Expression> left;
202         std::string component_group;
203         unsigned count;
204         UInt8 components[4];
205
206         Swizzle();
207
208         virtual Swizzle *clone() const { return new Swizzle(*this); }
209         virtual void visit(NodeVisitor &);
210 };
211
212 struct UnaryExpression: Expression
213 {
214         NodePtr<Expression> expression;
215
216         virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
217         virtual void visit(NodeVisitor &);
218 };
219
220 struct BinaryExpression: Expression
221 {
222         NodePtr<Expression> left;
223         NodePtr<Expression> right;
224
225         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
226         virtual void visit(NodeVisitor &);
227 };
228
229 struct Assignment: BinaryExpression
230 {
231         struct Target
232         {
233                 enum ChainType
234                 {
235                         MEMBER = 0x40,
236                         SWIZZLE = 0x80,
237                         ARRAY = 0xC0
238                 };
239
240                 Statement *declaration;
241                 Msp::UInt8 chain_len;
242                 Msp::UInt8 chain[7];
243
244                 Target(Statement * = 0);
245
246                 bool operator<(const Target &) const;
247         };
248
249         bool self_referencing;
250
251         Target target;
252
253         Assignment();
254         Assignment(const Assignment &);
255
256         virtual Assignment *clone() const { return new Assignment(*this); }
257         virtual void visit(NodeVisitor &);
258 };
259
260 struct TernaryExpression: Expression
261 {
262         NodePtr<Expression> condition;
263         NodePtr<Expression> true_expr;
264         NodePtr<Expression> false_expr;
265
266         virtual TernaryExpression *clone() const { return new TernaryExpression(*this); }
267         virtual void visit(NodeVisitor &);
268 };
269
270 struct FunctionCall: Expression
271 {
272         std::string name;
273         bool constructor;
274         NodeArray<Expression> arguments;
275
276         FunctionDeclaration *declaration;
277
278         FunctionCall();
279         FunctionCall(const FunctionCall &);
280
281         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
282         virtual void visit(NodeVisitor &);
283 };
284
285 struct ExpressionStatement: Statement
286 {
287         NodePtr<Expression> expression;
288
289         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
290         virtual void visit(NodeVisitor &);
291 };
292
293 struct Import: Statement
294 {
295         std::string module;
296
297         virtual Import *clone() const { return new Import(*this); }
298         virtual void visit(NodeVisitor &);
299 };
300
301 struct Precision: Statement
302 {
303         std::string precision;
304         std::string type;
305
306         virtual Precision *clone() const { return new Precision(*this); }
307         virtual void visit(NodeVisitor &);
308 };
309
310 struct Layout: Node
311 {
312         struct Qualifier
313         {
314                 std::string name;
315                 bool has_value;
316                 int value;
317
318                 Qualifier(const std::string &n = std::string()): name(n), has_value(false), value(0) { }
319                 Qualifier(const std::string &n, int v): name(n), has_value(true), value(v) { }
320         };
321
322         std::vector<Qualifier> qualifiers;
323
324         virtual Layout *clone() const { return new Layout(*this); }
325         virtual void visit(NodeVisitor &);
326 };
327
328 struct InterfaceLayout: Statement
329 {
330         std::string interface;
331         Layout layout;
332
333         virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
334         virtual void visit(NodeVisitor &);
335 };
336
337 struct TypeDeclaration: Statement
338 {
339         std::string name;
340
341         virtual TypeDeclaration *clone() const = 0;
342 };
343
344 struct BasicTypeDeclaration: TypeDeclaration
345 {
346         enum Kind
347         {
348                 ALIAS,
349                 VOID,
350                 BOOL,
351                 INT,
352                 FLOAT,
353                 VECTOR,
354                 MATRIX,
355                 ARRAY
356         };
357
358         Kind kind;
359         unsigned size;
360         bool sign;
361         std::string base;
362
363         TypeDeclaration *base_type;
364
365         BasicTypeDeclaration();
366         BasicTypeDeclaration(const BasicTypeDeclaration &);
367
368         virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
369         virtual void visit(NodeVisitor &);
370 };
371
372 struct ImageTypeDeclaration: TypeDeclaration
373 {
374         enum Dimensions
375         {
376                 ONE = 1,
377                 TWO,
378                 THREE,
379                 CUBE
380         };
381
382         Dimensions dimensions;
383         bool array;
384         bool sampled;
385         bool shadow;
386         std::string base;
387
388         TypeDeclaration *base_type;
389
390         ImageTypeDeclaration();
391
392         virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
393         virtual void visit(NodeVisitor &);
394 };
395
396 struct StructDeclaration: TypeDeclaration
397 {
398         Block members;
399
400         InterfaceBlock *interface_block;
401
402         StructDeclaration();
403         StructDeclaration(const StructDeclaration &);
404         ~StructDeclaration();
405
406         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
407         virtual void visit(NodeVisitor &);
408 };
409
410 struct VariableDeclaration: Statement
411 {
412         NodePtr<Layout> layout;
413         bool constant;
414         std::string sampling;
415         std::string interpolation;
416         std::string interface;
417         std::string precision;
418         std::string type;
419         std::string name;
420         bool array;
421         NodePtr<Expression> array_size;
422         NodePtr<Expression> init_expression;
423
424         TypeDeclaration *type_declaration;
425         VariableDeclaration *linked_declaration;
426
427         VariableDeclaration();
428         VariableDeclaration(const VariableDeclaration &);
429         ~VariableDeclaration();
430
431         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
432         virtual void visit(NodeVisitor &);
433 };
434
435 struct InterfaceBlock: Statement
436 {
437         NodePtr<Layout> layout;
438         std::string interface;
439         std::string block_name;
440         NodePtr<Block> members;
441         std::string instance_name;
442         bool array;
443
444         /* An interface block's ultimate base type is always a struct.  The
445         immediate type may be either that same struct or an array of it. */
446         TypeDeclaration *type_declaration;
447         StructDeclaration *struct_declaration;
448         InterfaceBlock *linked_block;
449
450         InterfaceBlock();
451         InterfaceBlock(const InterfaceBlock &);
452         ~InterfaceBlock();
453
454         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
455         virtual void visit(NodeVisitor &);
456 };
457
458 struct FunctionDeclaration: Statement
459 {
460         std::string return_type;
461         std::string name;
462         NodeArray<VariableDeclaration> parameters;
463         bool virtua;
464         bool overrd;
465         Block body;
466
467         std::string signature;
468         FunctionDeclaration *definition;
469         TypeDeclaration *return_type_declaration;
470
471         FunctionDeclaration();
472         FunctionDeclaration(const FunctionDeclaration &);
473
474         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
475         virtual void visit(NodeVisitor &);
476 };
477
478 struct Conditional: Statement
479 {
480         NodePtr<Expression> condition;
481         Block body;
482         Block else_body;
483
484         virtual Conditional *clone() const { return new Conditional(*this); }
485         virtual void visit(NodeVisitor &);
486 };
487
488 struct Iteration: Statement
489 {
490         NodePtr<Statement> init_statement;
491         NodePtr<Expression> condition;
492         NodePtr<Expression> loop_expression;
493         Block body;
494
495         virtual Iteration *clone() const { return new Iteration(*this); }
496         virtual void visit(NodeVisitor &);
497 };
498
499 struct Passthrough: Statement
500 {
501         NodePtr<Expression> subscript;
502
503         virtual Passthrough *clone() const { return new Passthrough(*this); }
504         virtual void visit(NodeVisitor &);
505 };
506
507 struct Return: Statement
508 {
509         NodePtr<Expression> expression;
510
511         virtual Return *clone() const { return new Return(*this); }
512         virtual void visit(NodeVisitor &);
513 };
514
515 struct Jump: Statement
516 {
517         std::string keyword;
518
519         virtual Jump *clone() const { return new Jump(*this); }
520         virtual void visit(NodeVisitor &);
521 };
522
523 struct Stage
524 {
525         enum Type
526         {
527                 SHARED,
528                 VERTEX,
529                 GEOMETRY,
530                 FRAGMENT
531         };
532
533         Type type;
534         Stage *previous;
535         Block content;
536         std::map<std::string, TypeDeclaration *> types;
537         std::map<std::string, InterfaceBlock *> interface_blocks;
538         std::map<std::string, FunctionDeclaration *> functions;
539         std::map<std::string, unsigned> locations;
540         std::map<std::string, unsigned> texture_bindings;
541         std::map<std::string, unsigned> uniform_block_bindings;
542         Features required_features;
543         std::vector<Diagnostic> diagnostics;
544
545         Stage(Type);
546
547         static const char *get_stage_name(Type);
548 };
549
550 struct Module
551 {
552         SourceMap source_map;
553         Stage shared;
554         std::list<Stage> stages;
555
556         Module();
557 };
558
559 std::string get_unused_variable_name(const Block &, const std::string &);
560
561 int get_layout_value(const Layout &, const std::string &, int = -1);
562 void add_to_chain(Assignment::Target &, Assignment::Target::ChainType, unsigned);
563
564 } // namespace SL
565 } // namespace GL
566 } // namespace Msp
567
568 #pragma pop_macro("interface")
569
570 #endif