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")
46 static const Operator operators[];
48 static const Operator &get_operator(const std::string &, Type);
65 Node(): source(GENERATED_SOURCE), line(1) { }
66 Node(const Node &n): source(n.source), line(n.line) { }
68 Node &operator=(const Node &);
72 virtual Node *clone() const = 0;
73 virtual void visit(NodeVisitor &) = 0;
77 class NodePtr: public RefPtr<T>
81 NodePtr(T *p): RefPtr<T>(p) { }
82 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
83 NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
86 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
89 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
93 class NodeContainer: public C
97 NodeContainer(const NodeContainer &);
101 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
105 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
108 struct TypeDeclaration;
109 struct VariableDeclaration;
110 struct InterfaceBlock;
111 struct FunctionDeclaration;
113 struct Statement: Node
115 virtual Statement *clone() const = 0;
120 NodeList<Statement> body;
123 std::map<std::string, VariableDeclaration *> variables;
127 Block(const Block &);
129 virtual Block *clone() const { return new Block(*this); }
130 virtual void visit(NodeVisitor &);
133 struct Expression: Node
135 const Operator *oper;
137 TypeDeclaration *type;
142 virtual Expression *clone() const = 0;
145 struct Literal: Expression
150 virtual Literal *clone() const { return new Literal(*this); }
151 virtual void visit(NodeVisitor &);
154 struct ParenthesizedExpression: Expression
156 NodePtr<Expression> expression;
158 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
159 virtual void visit(NodeVisitor &);
162 struct VariableReference: Expression
166 VariableDeclaration *declaration;
169 VariableReference(const VariableReference &);
171 virtual VariableReference *clone() const { return new VariableReference(*this); }
172 virtual void visit(NodeVisitor &);
175 struct InterfaceBlockReference: Expression
179 InterfaceBlock *declaration;
181 InterfaceBlockReference();
182 InterfaceBlockReference(const InterfaceBlockReference &);
184 virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
185 virtual void visit(NodeVisitor &);
188 struct MemberAccess: Expression
190 NodePtr<Expression> left;
193 VariableDeclaration *declaration;
196 MemberAccess(const MemberAccess &);
198 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
199 virtual void visit(NodeVisitor &);
202 struct Swizzle: Expression
204 NodePtr<Expression> left;
205 std::string component_group;
211 virtual Swizzle *clone() const { return new Swizzle(*this); }
212 virtual void visit(NodeVisitor &);
215 struct UnaryExpression: Expression
217 NodePtr<Expression> expression;
219 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
220 virtual void visit(NodeVisitor &);
223 struct BinaryExpression: Expression
225 NodePtr<Expression> left;
226 NodePtr<Expression> right;
228 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
229 virtual void visit(NodeVisitor &);
232 struct Assignment: BinaryExpression
243 Statement *declaration;
244 Msp::UInt8 chain_len;
247 Target(Statement * = 0);
249 bool operator<(const Target &) const;
252 bool self_referencing;
257 Assignment(const Assignment &);
259 virtual Assignment *clone() const { return new Assignment(*this); }
260 virtual void visit(NodeVisitor &);
263 struct TernaryExpression: Expression
265 NodePtr<Expression> condition;
266 NodePtr<Expression> true_expr;
267 NodePtr<Expression> false_expr;
269 virtual TernaryExpression *clone() const { return new TernaryExpression(*this); }
270 virtual void visit(NodeVisitor &);
273 struct FunctionCall: Expression
277 NodeArray<Expression> arguments;
279 FunctionDeclaration *declaration;
282 FunctionCall(const FunctionCall &);
284 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
285 virtual void visit(NodeVisitor &);
288 struct ExpressionStatement: Statement
290 NodePtr<Expression> expression;
292 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
293 virtual void visit(NodeVisitor &);
296 struct Import: Statement
300 virtual Import *clone() const { return new Import(*this); }
301 virtual void visit(NodeVisitor &);
304 struct Precision: Statement
306 std::string precision;
309 virtual Precision *clone() const { return new Precision(*this); }
310 virtual void visit(NodeVisitor &);
322 std::vector<Qualifier> qualifiers;
324 virtual Layout *clone() const { return new Layout(*this); }
325 virtual void visit(NodeVisitor &);
328 struct InterfaceLayout: Statement
330 std::string interface;
333 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
334 virtual void visit(NodeVisitor &);
337 struct TypeDeclaration: Statement
341 virtual TypeDeclaration *clone() const = 0;
344 struct BasicTypeDeclaration: TypeDeclaration
362 TypeDeclaration *base_type;
364 BasicTypeDeclaration();
365 BasicTypeDeclaration(const BasicTypeDeclaration &);
367 virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
368 virtual void visit(NodeVisitor &);
371 struct ImageTypeDeclaration: TypeDeclaration
381 Dimensions dimensions;
387 TypeDeclaration *base_type;
389 ImageTypeDeclaration();
391 virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
392 virtual void visit(NodeVisitor &);
395 struct StructDeclaration: TypeDeclaration
399 InterfaceBlock *interface_block;
402 StructDeclaration(const StructDeclaration &);
403 ~StructDeclaration();
405 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
406 virtual void visit(NodeVisitor &);
409 struct VariableDeclaration: Statement
411 NodePtr<Layout> layout;
413 std::string sampling;
414 std::string interpolation;
415 std::string interface;
416 std::string precision;
420 NodePtr<Expression> array_size;
421 NodePtr<Expression> init_expression;
423 TypeDeclaration *type_declaration;
424 VariableDeclaration *linked_declaration;
426 VariableDeclaration();
427 VariableDeclaration(const VariableDeclaration &);
428 ~VariableDeclaration();
430 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
431 virtual void visit(NodeVisitor &);
434 struct InterfaceBlock: Statement
436 std::string interface;
438 NodePtr<Block> members;
439 std::string instance_name;
442 /* An interface block's ultimate base type is always a struct. The
443 immediate type may be either that same struct or an array of it. */
444 TypeDeclaration *type_declaration;
445 StructDeclaration *struct_declaration;
446 InterfaceBlock *linked_block;
449 InterfaceBlock(const InterfaceBlock &);
452 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
453 virtual void visit(NodeVisitor &);
456 struct FunctionDeclaration: Statement
458 std::string return_type;
460 NodeArray<VariableDeclaration> parameters;
463 std::string signature;
464 FunctionDeclaration *definition;
465 TypeDeclaration *return_type_declaration;
467 FunctionDeclaration();
468 FunctionDeclaration(const FunctionDeclaration &);
470 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
471 virtual void visit(NodeVisitor &);
474 struct Conditional: Statement
476 NodePtr<Expression> condition;
480 virtual Conditional *clone() const { return new Conditional(*this); }
481 virtual void visit(NodeVisitor &);
484 struct Iteration: Statement
486 NodePtr<Statement> init_statement;
487 NodePtr<Expression> condition;
488 NodePtr<Expression> loop_expression;
491 virtual Iteration *clone() const { return new Iteration(*this); }
492 virtual void visit(NodeVisitor &);
495 struct Passthrough: Statement
497 NodePtr<Expression> subscript;
499 virtual Passthrough *clone() const { return new Passthrough(*this); }
500 virtual void visit(NodeVisitor &);
503 struct Return: Statement
505 NodePtr<Expression> expression;
507 virtual Return *clone() const { return new Return(*this); }
508 virtual void visit(NodeVisitor &);
511 struct Jump: Statement
515 virtual Jump *clone() const { return new Jump(*this); }
516 virtual void visit(NodeVisitor &);
532 std::map<std::string, TypeDeclaration *> types;
533 std::map<std::string, InterfaceBlock *> interface_blocks;
534 std::map<std::string, FunctionDeclaration *> functions;
535 std::map<std::string, unsigned> locations;
536 Features required_features;
537 std::vector<Diagnostic> diagnostics;
541 static const char *get_stage_name(Type);
546 SourceMap source_map;
548 std::list<Stage> stages;
557 #pragma pop_macro("interface")