]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/syntax.h
Support automatic generation of interface blocks
[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/refptr.h>
10 #include "features.h"
11 #include "sourcemap.h"
12
13 #pragma push_macro("interface")
14 #undef interface
15
16 namespace Msp {
17 namespace GL {
18 namespace SL {
19
20 struct Operator
21 {
22         enum Type
23         {
24                 NO_OPERATOR,
25                 BINARY,
26                 PREFIX,
27                 POSTFIX
28         };
29
30         enum Associativity
31         {
32                 LEFT_TO_RIGHT,
33                 RIGHT_TO_LEFT
34         };
35
36         char token[4];
37         unsigned precedence;
38         Type type;
39         Associativity assoc;
40
41         static const Operator operators[];
42 };
43
44 struct NodeVisitor;
45
46 struct Node
47 {
48 protected:
49         Node() { }
50         Node(const Node &) { }
51 private:
52         Node &operator=(const Node &);
53 public:
54         virtual ~Node() { }
55
56         virtual Node *clone() const = 0;
57         virtual void visit(NodeVisitor &) = 0;
58 };
59
60 template<typename T>
61 class NodePtr: public RefPtr<T>
62 {
63 public:
64         NodePtr() { }
65         NodePtr(T *p): RefPtr<T>(p) { }
66         NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
67         NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
68
69         template<typename U>
70         NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
71
72         template<typename U>
73         NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
74 };
75
76 template<typename C>
77 class NodeContainer: public C
78 {
79 public:
80         NodeContainer() { }
81         NodeContainer(const NodeContainer &);
82 };
83
84 template<typename T>
85 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
86 { };
87
88 template<typename T>
89 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
90 { };
91
92 struct StructDeclaration;
93 struct VariableDeclaration;
94 struct InterfaceBlock;
95 struct FunctionDeclaration;
96
97 struct Statement: Node
98 {
99         unsigned source;
100         unsigned line;
101
102         Statement();
103
104         virtual Statement *clone() const = 0;
105 };
106
107 struct Block: Node
108 {
109         NodeList<Statement> body;
110         bool use_braces;
111         std::map<std::string, StructDeclaration *> types;
112         std::map<std::string, VariableDeclaration *> variables;
113         std::map<std::string, InterfaceBlock *> interfaces;
114         Block *parent;
115
116         Block();
117         Block(const Block &);
118
119         virtual Block *clone() const { return new Block(*this); }
120         virtual void visit(NodeVisitor &);
121 };
122
123 struct Expression: Node
124 {
125         virtual Expression *clone() const = 0;
126 };
127
128 struct Literal: Expression
129 {
130         std::string token;
131
132         virtual Literal *clone() const { return new Literal(*this); }
133         virtual void visit(NodeVisitor &);
134 };
135
136 struct ParenthesizedExpression: Expression
137 {
138         NodePtr<Expression> expression;
139
140         virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
141         virtual void visit(NodeVisitor &);
142 };
143
144 struct VariableReference: Expression
145 {
146         std::string name;
147         VariableDeclaration *declaration;
148
149         VariableReference();
150         VariableReference(const VariableReference &);
151
152         virtual VariableReference *clone() const { return new VariableReference(*this); }
153         virtual void visit(NodeVisitor &);
154 };
155
156 struct InterfaceBlockReference: Expression
157 {
158         std::string name;
159         InterfaceBlock *declaration;
160
161         InterfaceBlockReference();
162         InterfaceBlockReference(const InterfaceBlockReference &);
163
164         virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
165         virtual void visit(NodeVisitor &);
166 };
167
168 struct MemberAccess: Expression
169 {
170         NodePtr<Expression> left;
171         std::string member;
172         VariableDeclaration *declaration;
173
174         MemberAccess();
175         MemberAccess(const MemberAccess &);
176
177         virtual MemberAccess *clone() const { return new MemberAccess(*this); }
178         virtual void visit(NodeVisitor &);
179 };
180
181 struct UnaryExpression: Expression
182 {
183         std::string oper;
184         NodePtr<Expression> expression;
185         bool prefix;
186
187         UnaryExpression();
188
189         virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
190         virtual void visit(NodeVisitor &);
191 };
192
193 struct BinaryExpression: Expression
194 {
195         NodePtr<Expression> left;
196         std::string oper;
197         NodePtr<Expression> right;
198         std::string after;
199
200         virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
201         virtual void visit(NodeVisitor &);
202 };
203
204 struct Assignment: BinaryExpression
205 {
206         bool self_referencing;
207         VariableDeclaration *target_declaration;
208
209         Assignment();
210         Assignment(const Assignment &);
211
212         virtual Assignment *clone() const { return new Assignment(*this); }
213         virtual void visit(NodeVisitor &);
214 };
215
216 struct FunctionCall: Expression
217 {
218         std::string name;
219         FunctionDeclaration *declaration;
220         bool constructor;
221         NodeArray<Expression> arguments;
222
223         FunctionCall();
224         FunctionCall(const FunctionCall &);
225
226         virtual FunctionCall *clone() const { return new FunctionCall(*this); }
227         virtual void visit(NodeVisitor &);
228 };
229
230 struct ExpressionStatement: Statement
231 {
232         NodePtr<Expression> expression;
233
234         virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
235         virtual void visit(NodeVisitor &);
236 };
237
238 struct Import: Statement
239 {
240         std::string module;
241
242         virtual Import *clone() const { return new Import(*this); }
243         virtual void visit(NodeVisitor &);
244 };
245
246 struct Precision: Statement
247 {
248         std::string precision;
249         std::string type;
250
251         virtual Precision *clone() const { return new Precision(*this); }
252         virtual void visit(NodeVisitor &);
253 };
254
255 struct Layout: Node
256 {
257         struct Qualifier
258         {
259                 std::string name;
260                 bool has_value;
261                 int value;
262         };
263
264         std::vector<Qualifier> qualifiers;
265
266         virtual Layout *clone() const { return new Layout(*this); }
267         virtual void visit(NodeVisitor &);
268 };
269
270 struct InterfaceLayout: Statement
271 {
272         std::string interface;
273         Layout layout;
274
275         virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
276         virtual void visit(NodeVisitor &);
277 };
278
279 struct StructDeclaration: Statement
280 {
281         std::string name;
282         Block members;
283
284         StructDeclaration();
285
286         virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
287         virtual void visit(NodeVisitor &);
288 };
289
290 struct VariableDeclaration: Statement
291 {
292         bool constant;
293         std::string sampling;
294         std::string interpolation;
295         std::string interface;
296         std::string precision;
297         std::string type;
298         StructDeclaration *type_declaration;
299         std::string name;
300         bool array;
301         NodePtr<Expression> array_size;
302         NodePtr<Expression> init_expression;
303         VariableDeclaration *linked_declaration;
304         NodePtr<Layout> layout;
305
306         VariableDeclaration();
307         VariableDeclaration(const VariableDeclaration &);
308
309         virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
310         virtual void visit(NodeVisitor &);
311 };
312
313 struct InterfaceBlock: Statement
314 {
315         std::string interface;
316         std::string name;
317         Block members;
318         std::string instance_name;
319         bool array;
320         InterfaceBlock *linked_block;
321
322         InterfaceBlock();
323         InterfaceBlock(const InterfaceBlock &);
324
325         virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
326         virtual void visit(NodeVisitor &);
327 };
328
329 struct FunctionDeclaration: Statement
330 {
331         std::string return_type;
332         std::string name;
333         NodeArray<VariableDeclaration> parameters;
334         FunctionDeclaration *definition;
335         Block body;
336
337         FunctionDeclaration();
338         FunctionDeclaration(const FunctionDeclaration &);
339
340         virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
341         virtual void visit(NodeVisitor &);
342 };
343
344 struct Conditional: Statement
345 {
346         NodePtr<Expression> condition;
347         Block body;
348         Block else_body;
349
350         virtual Conditional *clone() const { return new Conditional(*this); }
351         virtual void visit(NodeVisitor &);
352 };
353
354 struct Iteration: Statement
355 {
356         NodePtr<Node> init_statement;
357         NodePtr<Expression> condition;
358         NodePtr<Expression> loop_expression;
359         Block body;
360
361         virtual Iteration *clone() const { return new Iteration(*this); }
362         virtual void visit(NodeVisitor &);
363 };
364
365 struct Passthrough: Statement
366 {
367         NodePtr<Expression> subscript;
368
369         virtual Passthrough *clone() const { return new Passthrough(*this); }
370         virtual void visit(NodeVisitor &);
371 };
372
373 struct Return: Statement
374 {
375         NodePtr<Expression> expression;
376
377         virtual Return *clone() const { return new Return(*this); }
378         virtual void visit(NodeVisitor &);
379 };
380
381 struct Jump: Statement
382 {
383         std::string keyword;
384
385         virtual Jump *clone() const { return new Jump(*this); }
386         virtual void visit(NodeVisitor &);
387 };
388
389 struct Stage
390 {
391         enum Type
392         {
393                 SHARED,
394                 VERTEX,
395                 GEOMETRY,
396                 FRAGMENT
397         };
398
399         Type type;
400         Stage *previous;
401         Block content;
402         std::map<std::string, unsigned> locations;
403         Features required_features;
404
405         Stage(Type);
406
407         static const char *get_stage_name(Type);
408 };
409
410 struct Module
411 {
412         SourceMap source_map;
413         Stage shared;
414         std::list<Stage> stages;
415
416         Module();
417 };
418
419 } // namespace SL
420 } // namespace GL
421 } // namespace Msp
422
423 #pragma pop_macro("interface")
424
425 #endif