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 TypeDeclaration;
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;
134 TypeDeclaration *type;
139 virtual Expression *clone() const = 0;
142 struct Literal: Expression
147 virtual Literal *clone() const { return new Literal(*this); }
148 virtual void visit(NodeVisitor &);
151 struct ParenthesizedExpression: Expression
153 NodePtr<Expression> expression;
155 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
156 virtual void visit(NodeVisitor &);
159 struct VariableReference: Expression
163 VariableDeclaration *declaration;
166 VariableReference(const VariableReference &);
168 virtual VariableReference *clone() const { return new VariableReference(*this); }
169 virtual void visit(NodeVisitor &);
172 struct InterfaceBlockReference: Expression
176 InterfaceBlock *declaration;
178 InterfaceBlockReference();
179 InterfaceBlockReference(const InterfaceBlockReference &);
181 virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
182 virtual void visit(NodeVisitor &);
185 struct MemberAccess: Expression
187 NodePtr<Expression> left;
190 VariableDeclaration *declaration;
193 MemberAccess(const MemberAccess &);
195 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
196 virtual void visit(NodeVisitor &);
199 struct UnaryExpression: Expression
201 NodePtr<Expression> expression;
203 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
204 virtual void visit(NodeVisitor &);
207 struct BinaryExpression: Expression
209 NodePtr<Expression> left;
210 NodePtr<Expression> right;
212 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
213 virtual void visit(NodeVisitor &);
216 struct Assignment: BinaryExpression
218 bool self_referencing;
220 VariableDeclaration *target_declaration;
223 Assignment(const Assignment &);
225 virtual Assignment *clone() const { return new Assignment(*this); }
226 virtual void visit(NodeVisitor &);
229 struct FunctionCall: Expression
233 NodeArray<Expression> arguments;
235 FunctionDeclaration *declaration;
238 FunctionCall(const FunctionCall &);
240 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
241 virtual void visit(NodeVisitor &);
244 struct ExpressionStatement: Statement
246 NodePtr<Expression> expression;
248 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
249 virtual void visit(NodeVisitor &);
252 struct Import: Statement
256 virtual Import *clone() const { return new Import(*this); }
257 virtual void visit(NodeVisitor &);
260 struct Precision: Statement
262 std::string precision;
265 virtual Precision *clone() const { return new Precision(*this); }
266 virtual void visit(NodeVisitor &);
278 std::vector<Qualifier> qualifiers;
280 virtual Layout *clone() const { return new Layout(*this); }
281 virtual void visit(NodeVisitor &);
284 struct InterfaceLayout: Statement
286 std::string interface;
289 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
290 virtual void visit(NodeVisitor &);
293 struct TypeDeclaration: Statement
297 virtual TypeDeclaration *clone() const = 0;
300 struct BasicTypeDeclaration: TypeDeclaration
318 TypeDeclaration *base_type;
320 BasicTypeDeclaration();
321 BasicTypeDeclaration(const BasicTypeDeclaration &);
323 virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
324 virtual void visit(NodeVisitor &);
327 struct ImageTypeDeclaration: TypeDeclaration
337 Dimensions dimensions;
343 TypeDeclaration *base_type;
345 ImageTypeDeclaration();
347 virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
348 virtual void visit(NodeVisitor &);
351 struct StructDeclaration: TypeDeclaration
357 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
358 virtual void visit(NodeVisitor &);
361 struct VariableDeclaration: Statement
363 NodePtr<Layout> layout;
365 std::string sampling;
366 std::string interpolation;
367 std::string interface;
368 std::string precision;
372 NodePtr<Expression> array_size;
373 NodePtr<Expression> init_expression;
375 TypeDeclaration *type_declaration;
376 VariableDeclaration *linked_declaration;
378 VariableDeclaration();
379 VariableDeclaration(const VariableDeclaration &);
380 ~VariableDeclaration();
382 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
383 virtual void visit(NodeVisitor &);
386 struct InterfaceBlock: Statement
388 std::string interface;
391 std::string instance_name;
394 InterfaceBlock *linked_block;
397 InterfaceBlock(const InterfaceBlock &);
400 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
401 virtual void visit(NodeVisitor &);
404 struct FunctionDeclaration: Statement
406 std::string return_type;
408 NodeArray<VariableDeclaration> parameters;
411 FunctionDeclaration *definition;
412 TypeDeclaration *return_type_declaration;
414 FunctionDeclaration();
415 FunctionDeclaration(const FunctionDeclaration &);
417 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
418 virtual void visit(NodeVisitor &);
421 struct Conditional: Statement
423 NodePtr<Expression> condition;
427 virtual Conditional *clone() const { return new Conditional(*this); }
428 virtual void visit(NodeVisitor &);
431 struct Iteration: Statement
433 NodePtr<Statement> init_statement;
434 NodePtr<Expression> condition;
435 NodePtr<Expression> loop_expression;
438 virtual Iteration *clone() const { return new Iteration(*this); }
439 virtual void visit(NodeVisitor &);
442 struct Passthrough: Statement
444 NodePtr<Expression> subscript;
446 virtual Passthrough *clone() const { return new Passthrough(*this); }
447 virtual void visit(NodeVisitor &);
450 struct Return: Statement
452 NodePtr<Expression> expression;
454 virtual Return *clone() const { return new Return(*this); }
455 virtual void visit(NodeVisitor &);
458 struct Jump: Statement
462 virtual Jump *clone() const { return new Jump(*this); }
463 virtual void visit(NodeVisitor &);
479 std::map<std::string, TypeDeclaration *> types;
480 std::map<std::string, InterfaceBlock *> interface_blocks;
481 std::map<std::string, FunctionDeclaration *> functions;
482 std::map<std::string, unsigned> locations;
483 Features required_features;
484 std::vector<Diagnostic> diagnostics;
488 static const char *get_stage_name(Type);
493 SourceMap source_map;
495 std::list<Stage> stages;
504 #pragma pop_macro("interface")