1 #ifndef MSP_GL_PROGRAMSYNTAX_H_
2 #define MSP_GL_PROGRAMSYNTAX_H_
8 #include <msp/core/refptr.h>
12 #pragma push_macro("interface")
17 namespace ProgramSyntax {
24 Node &operator=(const Node &);
28 virtual Node *clone() const = 0;
29 virtual void visit(NodeVisitor &) = 0;
33 class NodePtr: public RefPtr<T>
37 NodePtr(T *p): RefPtr<T>(p) { }
38 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
41 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
44 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
48 class NodeContainer: public C
52 NodeContainer(const NodeContainer &);
56 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
60 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
63 struct StructDeclaration;
64 struct VariableDeclaration;
65 struct FunctionDeclaration;
71 std::map<std::string, StructDeclaration *> types;
72 std::map<std::string, VariableDeclaration *> variables;
76 virtual Block *clone() const { return new Block(*this); }
77 virtual void visit(NodeVisitor &);
80 struct Expression: Node
82 virtual Expression *clone() const = 0;
85 struct Literal: Expression
89 virtual Literal *clone() const { return new Literal(*this); }
90 virtual void visit(NodeVisitor &);
93 struct ParenthesizedExpression: Expression
95 NodePtr<Expression> expression;
97 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
98 virtual void visit(NodeVisitor &);
101 struct VariableReference: Expression
104 VariableDeclaration *declaration;
108 virtual VariableReference *clone() const { return new VariableReference(*this); }
109 virtual void visit(NodeVisitor &);
112 struct MemberAccess: Expression
114 NodePtr<Expression> left;
116 VariableDeclaration *declaration;
118 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
119 virtual void visit(NodeVisitor &);
122 struct UnaryExpression: Expression
125 NodePtr<Expression> expression;
130 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
131 virtual void visit(NodeVisitor &);
134 struct BinaryExpression: Expression
136 NodePtr<Expression> left;
138 NodePtr<Expression> right;
141 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
142 virtual void visit(NodeVisitor &);
145 struct Assignment: BinaryExpression
147 bool self_referencing;
148 VariableDeclaration *target_declaration;
152 virtual Assignment *clone() const { return new Assignment(*this); }
153 virtual void visit(NodeVisitor &);
156 struct FunctionCall: Expression
159 FunctionDeclaration *declaration;
161 NodeArray<Expression> arguments;
165 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
166 virtual void visit(NodeVisitor &);
169 struct ExpressionStatement: Node
171 NodePtr<Expression> expression;
173 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
174 virtual void visit(NodeVisitor &);
181 virtual Import *clone() const { return new Import(*this); }
182 virtual void visit(NodeVisitor &);
185 struct Precision: Node
187 std::string precision;
190 virtual Precision *clone() const { return new Precision(*this); }
191 virtual void visit(NodeVisitor &);
198 // TODO the standard calls this name, not identifier
199 std::string identifier;
203 std::vector<Qualifier> qualifiers;
205 virtual Layout *clone() const { return new Layout(*this); }
206 virtual void visit(NodeVisitor &);
209 struct InterfaceLayout: Node
211 std::string interface;
214 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
215 virtual void visit(NodeVisitor &);
218 struct StructDeclaration: Node
225 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
226 virtual void visit(NodeVisitor &);
229 struct VariableDeclaration: Node
232 std::string sampling;
233 std::string interpolation;
234 std::string interface;
235 std::string precision;
237 StructDeclaration *type_declaration;
240 NodePtr<Expression> array_size;
241 NodePtr<Expression> init_expression;
242 VariableDeclaration *linked_declaration;
243 NodePtr<Layout> layout;
245 VariableDeclaration();
247 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
248 virtual void visit(NodeVisitor &);
251 struct InterfaceBlock: Node
253 std::string interface;
256 std::string instance_name;
261 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
262 virtual void visit(NodeVisitor &);
265 struct FunctionDeclaration: Node
267 std::string return_type;
269 NodeArray<VariableDeclaration> parameters;
270 FunctionDeclaration *definition;
273 FunctionDeclaration();
274 FunctionDeclaration(const FunctionDeclaration &);
276 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
277 virtual void visit(NodeVisitor &);
280 struct Conditional: Node
282 NodePtr<Expression> condition;
286 virtual Conditional *clone() const { return new Conditional(*this); }
287 virtual void visit(NodeVisitor &);
290 struct Iteration: Node
292 NodePtr<Node> init_statement;
293 NodePtr<Expression> condition;
294 NodePtr<Expression> loop_expression;
297 virtual Iteration *clone() const { return new Iteration(*this); }
298 virtual void visit(NodeVisitor &);
301 struct Passthrough: Node
303 NodePtr<Expression> subscript;
305 virtual Passthrough *clone() const { return new Passthrough(*this); }
306 virtual void visit(NodeVisitor &);
311 NodePtr<Expression> expression;
313 virtual Return *clone() const { return new Return(*this); }
314 virtual void visit(NodeVisitor &);
321 virtual Jump *clone() const { return new Jump(*this); }
322 virtual void visit(NodeVisitor &);
327 virtual ~NodeVisitor() { }
329 virtual void visit(Block &) { }
330 virtual void visit(Literal &) { }
331 virtual void visit(ParenthesizedExpression &) { }
332 virtual void visit(VariableReference &) { }
333 virtual void visit(MemberAccess &) { }
334 virtual void visit(UnaryExpression &) { }
335 virtual void visit(BinaryExpression &) { }
336 virtual void visit(Assignment &);
337 virtual void visit(FunctionCall &) { }
338 virtual void visit(ExpressionStatement &) { }
339 virtual void visit(Import &) { }
340 virtual void visit(Precision &) { }
341 virtual void visit(Layout &) { }
342 virtual void visit(InterfaceLayout &) { }
343 virtual void visit(StructDeclaration &) { }
344 virtual void visit(VariableDeclaration &) { }
345 virtual void visit(InterfaceBlock &) { }
346 virtual void visit(FunctionDeclaration &) { }
347 virtual void visit(Conditional &) { }
348 virtual void visit(Iteration &) { }
349 virtual void visit(Passthrough &) { }
350 virtual void visit(Return &) { }
351 virtual void visit(Jump &) { }
354 struct TraversingVisitor: NodeVisitor
356 using NodeVisitor::visit;
357 virtual void visit(Block &);
358 virtual void visit(ParenthesizedExpression &);
359 virtual void visit(MemberAccess &);
360 virtual void visit(UnaryExpression &);
361 virtual void visit(BinaryExpression &);
362 virtual void visit(FunctionCall &);
363 virtual void visit(ExpressionStatement &);
364 virtual void visit(InterfaceLayout &);
365 virtual void visit(StructDeclaration &);
366 virtual void visit(VariableDeclaration &);
367 virtual void visit(InterfaceBlock &);
368 virtual void visit(FunctionDeclaration &);
369 virtual void visit(Conditional &);
370 virtual void visit(Iteration &);
371 virtual void visit(Passthrough &);
372 virtual void visit(Return &);
387 ProgramSyntax::Block content;
388 std::map<std::string, VariableDeclaration *> in_variables;
389 std::map<std::string, VariableDeclaration *> out_variables;
390 std::map<std::string, unsigned> locations;
391 Version required_version;
399 std::list<Stage> stages;
404 } // namespace ProgramSyntax
408 #pragma pop_macro("interface")