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")
47 static const Operator operators[];
49 static const Operator &get_operator(const std::string &, Type);
66 Node(): source(GENERATED_SOURCE), line(1) { }
67 Node(const Node &n): source(n.source), line(n.line) { }
69 Node &operator=(const Node &);
73 virtual Node *clone() const = 0;
74 virtual void visit(NodeVisitor &) = 0;
78 class NodePtr: public RefPtr<T>
82 NodePtr(T *p): RefPtr<T>(p) { }
83 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
84 NodePtr &operator=(const NodePtr &p) { RefPtr<T>::operator=(p); return *this; }
87 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
90 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
94 class NodeContainer: public C
98 NodeContainer(const NodeContainer &);
100 void push_back_nocopy(const typename C::value_type &v)
101 { C::push_back(0); C::back() = v; }
105 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
109 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
112 struct TypeDeclaration;
113 struct VariableDeclaration;
114 struct InterfaceBlock;
115 struct FunctionDeclaration;
117 struct Statement: Node
119 virtual Statement *clone() const = 0;
124 NodeList<Statement> body;
127 std::map<std::string, VariableDeclaration *> variables;
131 Block(const Block &);
133 virtual Block *clone() const { return new Block(*this); }
134 virtual void visit(NodeVisitor &);
137 struct Expression: Node
139 const Operator *oper;
141 TypeDeclaration *type;
146 virtual Expression *clone() const = 0;
149 struct Literal: Expression
154 virtual Literal *clone() const { return new Literal(*this); }
155 virtual void visit(NodeVisitor &);
158 struct VariableReference: Expression
162 VariableDeclaration *declaration;
165 VariableReference(const VariableReference &);
167 virtual VariableReference *clone() const { return new VariableReference(*this); }
168 virtual void visit(NodeVisitor &);
171 struct InterfaceBlockReference: Expression
175 InterfaceBlock *declaration;
177 InterfaceBlockReference();
178 InterfaceBlockReference(const InterfaceBlockReference &);
180 virtual InterfaceBlockReference *clone() const { return new InterfaceBlockReference(*this); }
181 virtual void visit(NodeVisitor &);
184 struct MemberAccess: Expression
186 NodePtr<Expression> left;
189 VariableDeclaration *declaration;
193 MemberAccess(const MemberAccess &);
195 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
196 virtual void visit(NodeVisitor &);
199 struct Swizzle: Expression
201 NodePtr<Expression> left;
202 std::string component_group;
208 virtual Swizzle *clone() const { return new Swizzle(*this); }
209 virtual void visit(NodeVisitor &);
212 struct UnaryExpression: Expression
214 NodePtr<Expression> expression;
216 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
217 virtual void visit(NodeVisitor &);
220 struct BinaryExpression: Expression
222 NodePtr<Expression> left;
223 NodePtr<Expression> right;
225 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
226 virtual void visit(NodeVisitor &);
229 struct Assignment: BinaryExpression
240 Statement *declaration;
241 Msp::UInt8 chain_len;
244 Target(Statement * = 0);
246 bool operator<(const Target &) const;
249 bool self_referencing;
254 Assignment(const Assignment &);
256 virtual Assignment *clone() const { return new Assignment(*this); }
257 virtual void visit(NodeVisitor &);
260 struct TernaryExpression: Expression
262 NodePtr<Expression> condition;
263 NodePtr<Expression> true_expr;
264 NodePtr<Expression> false_expr;
266 virtual TernaryExpression *clone() const { return new TernaryExpression(*this); }
267 virtual void visit(NodeVisitor &);
270 struct FunctionCall: Expression
274 NodeArray<Expression> arguments;
276 FunctionDeclaration *declaration;
279 FunctionCall(const FunctionCall &);
281 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
282 virtual void visit(NodeVisitor &);
285 struct ExpressionStatement: Statement
287 NodePtr<Expression> expression;
289 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
290 virtual void visit(NodeVisitor &);
293 struct Import: Statement
297 virtual Import *clone() const { return new Import(*this); }
298 virtual void visit(NodeVisitor &);
301 struct Precision: Statement
303 std::string precision;
306 virtual Precision *clone() const { return new Precision(*this); }
307 virtual void visit(NodeVisitor &);
318 Qualifier(): has_value(false), value(0) { }
321 std::vector<Qualifier> qualifiers;
323 virtual Layout *clone() const { return new Layout(*this); }
324 virtual void visit(NodeVisitor &);
327 struct InterfaceLayout: Statement
329 std::string interface;
332 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
333 virtual void visit(NodeVisitor &);
336 struct TypeDeclaration: Statement
340 virtual TypeDeclaration *clone() const = 0;
343 struct BasicTypeDeclaration: TypeDeclaration
361 TypeDeclaration *base_type;
363 BasicTypeDeclaration();
364 BasicTypeDeclaration(const BasicTypeDeclaration &);
366 virtual BasicTypeDeclaration *clone() const { return new BasicTypeDeclaration(*this); }
367 virtual void visit(NodeVisitor &);
370 struct ImageTypeDeclaration: TypeDeclaration
380 Dimensions dimensions;
386 TypeDeclaration *base_type;
388 ImageTypeDeclaration();
390 virtual ImageTypeDeclaration *clone() const { return new ImageTypeDeclaration(*this); }
391 virtual void visit(NodeVisitor &);
394 struct StructDeclaration: TypeDeclaration
398 InterfaceBlock *interface_block;
401 StructDeclaration(const StructDeclaration &);
402 ~StructDeclaration();
404 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
405 virtual void visit(NodeVisitor &);
408 struct VariableDeclaration: Statement
410 NodePtr<Layout> layout;
412 std::string sampling;
413 std::string interpolation;
414 std::string interface;
415 std::string precision;
419 NodePtr<Expression> array_size;
420 NodePtr<Expression> init_expression;
422 TypeDeclaration *type_declaration;
423 VariableDeclaration *linked_declaration;
425 VariableDeclaration();
426 VariableDeclaration(const VariableDeclaration &);
427 ~VariableDeclaration();
429 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
430 virtual void visit(NodeVisitor &);
433 struct InterfaceBlock: Statement
435 NodePtr<Layout> layout;
436 std::string interface;
437 std::string block_name;
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;
465 std::string signature;
466 FunctionDeclaration *definition;
467 TypeDeclaration *return_type_declaration;
469 FunctionDeclaration();
470 FunctionDeclaration(const FunctionDeclaration &);
472 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
473 virtual void visit(NodeVisitor &);
476 struct Conditional: Statement
478 NodePtr<Expression> condition;
482 virtual Conditional *clone() const { return new Conditional(*this); }
483 virtual void visit(NodeVisitor &);
486 struct Iteration: Statement
488 NodePtr<Statement> init_statement;
489 NodePtr<Expression> condition;
490 NodePtr<Expression> loop_expression;
493 virtual Iteration *clone() const { return new Iteration(*this); }
494 virtual void visit(NodeVisitor &);
497 struct Passthrough: Statement
499 NodePtr<Expression> subscript;
501 virtual Passthrough *clone() const { return new Passthrough(*this); }
502 virtual void visit(NodeVisitor &);
505 struct Return: Statement
507 NodePtr<Expression> expression;
509 virtual Return *clone() const { return new Return(*this); }
510 virtual void visit(NodeVisitor &);
513 struct Jump: Statement
517 virtual Jump *clone() const { return new Jump(*this); }
518 virtual void visit(NodeVisitor &);
534 std::map<std::string, TypeDeclaration *> types;
535 std::map<std::string, InterfaceBlock *> interface_blocks;
536 std::map<std::string, FunctionDeclaration *> functions;
537 std::map<std::string, unsigned> locations;
538 std::map<std::string, unsigned> texture_bindings;
539 std::map<std::string, unsigned> uniform_block_bindings;
540 Features required_features;
541 std::vector<Diagnostic> diagnostics;
545 static const char *get_stage_name(Type);
550 SourceMap source_map;
552 std::list<Stage> stages;
557 std::string get_unused_variable_name(const Block &, const std::string &);
559 bool is_same_type(const TypeDeclaration &, const TypeDeclaration &);
560 int get_layout_value(const Layout &, const std::string &, int = -1);
566 #pragma pop_macro("interface")