1 #ifndef MSP_GL_SL_SYNTAX_H_
2 #define MSP_GL_SL_SYNTAX_H_
9 #include <msp/core/inttypes.h>
10 #include <msp/core/refptr.h>
11 #include <msp/core/variant.h>
13 #include "glsl_error.h"
14 #include "sourcemap.h"
16 #pragma push_macro("interface")
45 static const Operator operators[];
47 static const Operator &get_operator(const std::string &, Type);
64 Node(): source(GENERATED_SOURCE), line(1) { }
65 Node(const Node &n): source(n.source), line(n.line) { }
67 Node &operator=(const Node &);
71 virtual Node *clone() const = 0;
72 virtual void visit(NodeVisitor &) = 0;
76 class NodePtr: public RefPtr<T>
80 NodePtr(T *p): RefPtr<T>(p) { }
81 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
82 NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
85 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
88 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
92 class NodeContainer: public C
96 NodeContainer(const NodeContainer &);
100 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
104 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
107 struct TypeDeclaration;
108 struct VariableDeclaration;
109 struct InterfaceBlock;
110 struct FunctionDeclaration;
112 struct Statement: Node
114 virtual Statement *clone() const = 0;
119 NodeList<Statement> body;
122 std::map<std::string, VariableDeclaration *> variables;
126 Block(const Block &);
128 virtual Block *clone() const { return new Block(*this); }
129 virtual void visit(NodeVisitor &);
132 struct Expression: Node
134 const Operator *oper;
136 TypeDeclaration *type;
141 virtual Expression *clone() const = 0;
144 struct Literal: Expression
149 virtual Literal *clone() const { return new Literal(*this); }
150 virtual void visit(NodeVisitor &);
153 struct ParenthesizedExpression: Expression
155 NodePtr<Expression> expression;
157 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
158 virtual void visit(NodeVisitor &);
161 struct VariableReference: Expression
165 VariableDeclaration *declaration;
168 VariableReference(const VariableReference &);
170 virtual VariableReference *clone() const { return new VariableReference(*this); }
171 virtual void visit(NodeVisitor &);
174 struct InterfaceBlockReference: Expression
178 InterfaceBlock *declaration;
180 InterfaceBlockReference();
181 InterfaceBlockReference(const InterfaceBlockReference &);
183 virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
184 virtual void visit(NodeVisitor &);
187 struct MemberAccess: Expression
189 NodePtr<Expression> left;
192 VariableDeclaration *declaration;
195 MemberAccess(const MemberAccess &);
197 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
198 virtual void visit(NodeVisitor &);
201 struct Swizzle: Expression
203 NodePtr<Expression> left;
204 std::string component_group;
210 virtual Swizzle *clone() const { return new Swizzle(*this); }
211 virtual void visit(NodeVisitor &);
214 struct UnaryExpression: Expression
216 NodePtr<Expression> expression;
218 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
219 virtual void visit(NodeVisitor &);
222 struct BinaryExpression: Expression
224 NodePtr<Expression> left;
225 NodePtr<Expression> right;
227 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
228 virtual void visit(NodeVisitor &);
231 struct Assignment: BinaryExpression
233 bool self_referencing;
235 VariableDeclaration *target_declaration;
238 Assignment(const Assignment &);
240 virtual Assignment *clone() const { return new Assignment(*this); }
241 virtual void visit(NodeVisitor &);
244 struct FunctionCall: Expression
248 NodeArray<Expression> arguments;
250 FunctionDeclaration *declaration;
253 FunctionCall(const FunctionCall &);
255 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
256 virtual void visit(NodeVisitor &);
259 struct ExpressionStatement: Statement
261 NodePtr<Expression> expression;
263 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
264 virtual void visit(NodeVisitor &);
267 struct Import: Statement
271 virtual Import *clone() const { return new Import(*this); }
272 virtual void visit(NodeVisitor &);
275 struct Precision: Statement
277 std::string precision;
280 virtual Precision *clone() const { return new Precision(*this); }
281 virtual void visit(NodeVisitor &);
293 std::vector<Qualifier> qualifiers;
295 virtual Layout *clone() const { return new Layout(*this); }
296 virtual void visit(NodeVisitor &);
299 struct InterfaceLayout: Statement
301 std::string interface;
304 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
305 virtual void visit(NodeVisitor &);
308 struct TypeDeclaration: Statement
312 virtual TypeDeclaration *clone() const = 0;
315 struct BasicTypeDeclaration: TypeDeclaration
333 TypeDeclaration *base_type;
335 BasicTypeDeclaration();
336 BasicTypeDeclaration(const BasicTypeDeclaration &);
338 virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
339 virtual void visit(NodeVisitor &);
342 struct ImageTypeDeclaration: TypeDeclaration
352 Dimensions dimensions;
358 TypeDeclaration *base_type;
360 ImageTypeDeclaration();
362 virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
363 virtual void visit(NodeVisitor &);
366 struct StructDeclaration: TypeDeclaration
370 InterfaceBlock *interface_block;
373 StructDeclaration(const StructDeclaration &);
374 ~StructDeclaration();
376 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
377 virtual void visit(NodeVisitor &);
380 struct VariableDeclaration: Statement
382 NodePtr<Layout> layout;
384 std::string sampling;
385 std::string interpolation;
386 std::string interface;
387 std::string precision;
391 NodePtr<Expression> array_size;
392 NodePtr<Expression> init_expression;
394 TypeDeclaration *type_declaration;
395 VariableDeclaration *linked_declaration;
397 VariableDeclaration();
398 VariableDeclaration(const VariableDeclaration &);
399 ~VariableDeclaration();
401 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
402 virtual void visit(NodeVisitor &);
405 struct InterfaceBlock: Statement
407 std::string interface;
409 NodePtr<Block> members;
410 std::string instance_name;
413 /* An interface block's ultimate base type is always a struct. The
414 immediate type may be either that same struct or an array of it. */
415 TypeDeclaration *type_declaration;
416 StructDeclaration *struct_declaration;
417 InterfaceBlock *linked_block;
420 InterfaceBlock(const InterfaceBlock &);
423 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
424 virtual void visit(NodeVisitor &);
427 struct FunctionDeclaration: Statement
429 std::string return_type;
431 NodeArray<VariableDeclaration> parameters;
434 FunctionDeclaration *definition;
435 TypeDeclaration *return_type_declaration;
437 FunctionDeclaration();
438 FunctionDeclaration(const FunctionDeclaration &);
440 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
441 virtual void visit(NodeVisitor &);
444 struct Conditional: Statement
446 NodePtr<Expression> condition;
450 virtual Conditional *clone() const { return new Conditional(*this); }
451 virtual void visit(NodeVisitor &);
454 struct Iteration: Statement
456 NodePtr<Statement> init_statement;
457 NodePtr<Expression> condition;
458 NodePtr<Expression> loop_expression;
461 virtual Iteration *clone() const { return new Iteration(*this); }
462 virtual void visit(NodeVisitor &);
465 struct Passthrough: Statement
467 NodePtr<Expression> subscript;
469 virtual Passthrough *clone() const { return new Passthrough(*this); }
470 virtual void visit(NodeVisitor &);
473 struct Return: Statement
475 NodePtr<Expression> expression;
477 virtual Return *clone() const { return new Return(*this); }
478 virtual void visit(NodeVisitor &);
481 struct Jump: Statement
485 virtual Jump *clone() const { return new Jump(*this); }
486 virtual void visit(NodeVisitor &);
502 std::map<std::string, TypeDeclaration *> types;
503 std::map<std::string, InterfaceBlock *> interface_blocks;
504 std::map<std::string, FunctionDeclaration *> functions;
505 std::map<std::string, unsigned> locations;
506 Features required_features;
507 std::vector<Diagnostic> diagnostics;
511 static const char *get_stage_name(Type);
516 SourceMap source_map;
518 std::list<Stage> stages;
527 #pragma pop_macro("interface")