1 #ifndef MSP_GL_SL_SYNTAX_H_
2 #define MSP_GL_SL_SYNTAX_H_
9 #include <msp/core/refptr.h>
10 #include <msp/core/variant.h>
12 #include "glsl_error.h"
13 #include "sourcemap.h"
15 #pragma push_macro("interface")
44 static const Operator operators[];
46 static const Operator &get_operator(const std::string &, Type);
62 Node(): source(GENERATED_SOURCE), line(1) { }
63 Node(const Node &n): source(n.source), line(n.line) { }
65 Node &operator=(const Node &);
69 virtual Node *clone() const = 0;
70 virtual void visit(NodeVisitor &) = 0;
74 class NodePtr: public RefPtr<T>
78 NodePtr(T *p): RefPtr<T>(p) { }
79 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
80 NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
83 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
86 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
90 class NodeContainer: public C
94 NodeContainer(const NodeContainer &);
98 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
102 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
105 struct StructDeclaration;
106 struct VariableDeclaration;
107 struct InterfaceBlock;
108 struct FunctionDeclaration;
110 struct Statement: Node
112 virtual Statement *clone() const = 0;
117 NodeList<Statement> body;
120 std::map<std::string, VariableDeclaration *> variables;
124 Block(const Block &);
126 virtual Block *clone() const { return new Block(*this); }
127 virtual void visit(NodeVisitor &);
130 struct Expression: Node
132 const Operator *oper;
136 virtual Expression *clone() const = 0;
139 struct Literal: Expression
144 virtual Literal *clone() const { return new Literal(*this); }
145 virtual void visit(NodeVisitor &);
148 struct ParenthesizedExpression: Expression
150 NodePtr<Expression> expression;
152 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
153 virtual void visit(NodeVisitor &);
156 struct VariableReference: Expression
160 VariableDeclaration *declaration;
163 VariableReference(const VariableReference &);
165 virtual VariableReference *clone() const { return new VariableReference(*this); }
166 virtual void visit(NodeVisitor &);
169 struct InterfaceBlockReference: Expression
173 InterfaceBlock *declaration;
175 InterfaceBlockReference();
176 InterfaceBlockReference(const InterfaceBlockReference &);
178 virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
179 virtual void visit(NodeVisitor &);
182 struct MemberAccess: Expression
184 NodePtr<Expression> left;
187 VariableDeclaration *declaration;
190 MemberAccess(const MemberAccess &);
192 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
193 virtual void visit(NodeVisitor &);
196 struct UnaryExpression: Expression
198 NodePtr<Expression> expression;
200 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
201 virtual void visit(NodeVisitor &);
204 struct BinaryExpression: Expression
206 NodePtr<Expression> left;
207 NodePtr<Expression> right;
209 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
210 virtual void visit(NodeVisitor &);
213 struct Assignment: BinaryExpression
215 bool self_referencing;
217 VariableDeclaration *target_declaration;
220 Assignment(const Assignment &);
222 virtual Assignment *clone() const { return new Assignment(*this); }
223 virtual void visit(NodeVisitor &);
226 struct FunctionCall: Expression
230 NodeArray<Expression> arguments;
232 FunctionDeclaration *declaration;
235 FunctionCall(const FunctionCall &);
237 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
238 virtual void visit(NodeVisitor &);
241 struct ExpressionStatement: Statement
243 NodePtr<Expression> expression;
245 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
246 virtual void visit(NodeVisitor &);
249 struct Import: Statement
253 virtual Import *clone() const { return new Import(*this); }
254 virtual void visit(NodeVisitor &);
257 struct Precision: Statement
259 std::string precision;
262 virtual Precision *clone() const { return new Precision(*this); }
263 virtual void visit(NodeVisitor &);
275 std::vector<Qualifier> qualifiers;
277 virtual Layout *clone() const { return new Layout(*this); }
278 virtual void visit(NodeVisitor &);
281 struct InterfaceLayout: Statement
283 std::string interface;
286 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
287 virtual void visit(NodeVisitor &);
290 struct TypeDeclaration: Statement
294 virtual TypeDeclaration *clone() const = 0;
297 struct BasicTypeDeclaration: TypeDeclaration
315 TypeDeclaration *base_type;
317 BasicTypeDeclaration();
318 BasicTypeDeclaration(const BasicTypeDeclaration &);
320 virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
321 virtual void visit(NodeVisitor &);
324 struct ImageTypeDeclaration: TypeDeclaration
334 Dimensions dimensions;
340 TypeDeclaration *base_type;
342 ImageTypeDeclaration();
344 virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
345 virtual void visit(NodeVisitor &);
348 struct StructDeclaration: TypeDeclaration
354 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
355 virtual void visit(NodeVisitor &);
358 struct VariableDeclaration: Statement
360 NodePtr<Layout> layout;
362 std::string sampling;
363 std::string interpolation;
364 std::string interface;
365 std::string precision;
369 NodePtr<Expression> array_size;
370 NodePtr<Expression> init_expression;
372 TypeDeclaration *type_declaration;
373 VariableDeclaration *linked_declaration;
375 VariableDeclaration();
376 VariableDeclaration(const VariableDeclaration &);
377 ~VariableDeclaration();
379 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
380 virtual void visit(NodeVisitor &);
383 struct InterfaceBlock: Statement
385 std::string interface;
388 std::string instance_name;
391 InterfaceBlock *linked_block;
394 InterfaceBlock(const InterfaceBlock &);
397 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
398 virtual void visit(NodeVisitor &);
401 struct FunctionDeclaration: Statement
403 std::string return_type;
405 NodeArray<VariableDeclaration> parameters;
408 FunctionDeclaration *definition;
409 TypeDeclaration *return_type_declaration;
411 FunctionDeclaration();
412 FunctionDeclaration(const FunctionDeclaration &);
414 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
415 virtual void visit(NodeVisitor &);
418 struct Conditional: Statement
420 NodePtr<Expression> condition;
424 virtual Conditional *clone() const { return new Conditional(*this); }
425 virtual void visit(NodeVisitor &);
428 struct Iteration: Statement
430 NodePtr<Statement> init_statement;
431 NodePtr<Expression> condition;
432 NodePtr<Expression> loop_expression;
435 virtual Iteration *clone() const { return new Iteration(*this); }
436 virtual void visit(NodeVisitor &);
439 struct Passthrough: Statement
441 NodePtr<Expression> subscript;
443 virtual Passthrough *clone() const { return new Passthrough(*this); }
444 virtual void visit(NodeVisitor &);
447 struct Return: Statement
449 NodePtr<Expression> expression;
451 virtual Return *clone() const { return new Return(*this); }
452 virtual void visit(NodeVisitor &);
455 struct Jump: Statement
459 virtual Jump *clone() const { return new Jump(*this); }
460 virtual void visit(NodeVisitor &);
476 std::map<std::string, TypeDeclaration *> types;
477 std::map<std::string, InterfaceBlock *> interface_blocks;
478 std::map<std::string, FunctionDeclaration *> functions;
479 std::map<std::string, unsigned> locations;
480 Features required_features;
481 std::vector<Diagnostic> diagnostics;
485 static const char *get_stage_name(Type);
490 SourceMap source_map;
492 std::list<Stage> stages;
501 #pragma pop_macro("interface")