1 #ifndef MSP_GL_PROGRAMSYNTAX_H_
2 #define MSP_GL_PROGRAMSYNTAX_H_
8 #include <msp/core/refptr.h>
13 namespace ProgramSyntax {
20 Node &operator=(const Node &);
24 virtual Node *clone() const = 0;
25 virtual void visit(NodeVisitor &) = 0;
29 class NodePtr: public RefPtr<T>
33 NodePtr(T *p): RefPtr<T>(p) { }
34 NodePtr(const NodePtr &p): RefPtr<T>(p ? p->clone() : 0) { }
37 NodePtr(const RefPtr<U> &p): RefPtr<T>(p) { }
40 NodePtr(const NodePtr<U> &p): RefPtr<T>(p ? p->clone() : 0) { }
44 class NodeContainer: public C
48 NodeContainer(const NodeContainer &);
52 class NodeList: public NodeContainer<std::list<RefPtr<T> > >
56 class NodeArray: public NodeContainer<std::vector<RefPtr<T> > >
59 struct StructDeclaration;
60 struct VariableDeclaration;
61 struct FunctionDeclaration;
67 std::map<std::string, StructDeclaration *> types;
68 std::map<std::string, VariableDeclaration *> variables;
72 virtual Block *clone() const { return new Block(*this); }
73 virtual void visit(NodeVisitor &);
76 struct Expression: Node
78 virtual Expression *clone() const = 0;
81 struct Literal: Expression
85 virtual Literal *clone() const { return new Literal(*this); }
86 virtual void visit(NodeVisitor &);
89 struct ParenthesizedExpression: Expression
91 NodePtr<Expression> expression;
93 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
94 virtual void visit(NodeVisitor &);
97 struct VariableReference: Expression
100 VariableDeclaration *declaration;
104 virtual VariableReference *clone() const { return new VariableReference(*this); }
105 virtual void visit(NodeVisitor &);
108 struct MemberAccess: Expression
110 NodePtr<Expression> left;
112 VariableDeclaration *declaration;
114 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
115 virtual void visit(NodeVisitor &);
118 struct UnaryExpression: Expression
121 NodePtr<Expression> expression;
126 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
127 virtual void visit(NodeVisitor &);
130 struct BinaryExpression: Expression
132 NodePtr<Expression> left;
134 NodePtr<Expression> right;
137 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
138 virtual void visit(NodeVisitor &);
141 struct Assignment: BinaryExpression
143 bool self_referencing;
144 VariableDeclaration *target_declaration;
148 virtual Assignment *clone() const { return new Assignment(*this); }
149 virtual void visit(NodeVisitor &);
152 struct FunctionCall: Expression
155 FunctionDeclaration *declaration;
157 NodeArray<Expression> arguments;
161 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
162 virtual void visit(NodeVisitor &);
165 struct ExpressionStatement: Node
167 NodePtr<Expression> expression;
169 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
170 virtual void visit(NodeVisitor &);
177 virtual Import *clone() const { return new Import(*this); }
178 virtual void visit(NodeVisitor &);
181 struct Precision: Node
183 std::string precision;
186 virtual Precision *clone() const { return new Precision(*this); }
187 virtual void visit(NodeVisitor &);
194 // TODO the standard calls this name, not identifier
195 std::string identifier;
199 std::vector<Qualifier> qualifiers;
201 virtual Layout *clone() const { return new Layout(*this); }
202 virtual void visit(NodeVisitor &);
205 struct InterfaceLayout: Node
207 std::string interface;
210 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
211 virtual void visit(NodeVisitor &);
214 struct StructDeclaration: Node
221 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
222 virtual void visit(NodeVisitor &);
225 struct VariableDeclaration: Node
228 std::string sampling;
229 std::string interpolation;
230 std::string interface;
231 std::string precision;
233 StructDeclaration *type_declaration;
236 NodePtr<Expression> array_size;
237 NodePtr<Expression> init_expression;
238 VariableDeclaration *linked_declaration;
239 NodePtr<Layout> layout;
241 VariableDeclaration();
243 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
244 virtual void visit(NodeVisitor &);
247 struct InterfaceBlock: Node
249 std::string interface;
252 std::string instance_name;
257 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
258 virtual void visit(NodeVisitor &);
261 struct FunctionDeclaration: Node
263 std::string return_type;
265 NodeArray<VariableDeclaration> parameters;
266 FunctionDeclaration *definition;
269 FunctionDeclaration();
270 FunctionDeclaration(const FunctionDeclaration &);
272 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
273 virtual void visit(NodeVisitor &);
276 struct Conditional: Node
278 NodePtr<Expression> condition;
282 virtual Conditional *clone() const { return new Conditional(*this); }
283 virtual void visit(NodeVisitor &);
286 struct Iteration: Node
288 NodePtr<Node> init_statement;
289 NodePtr<Expression> condition;
290 NodePtr<Expression> loop_expression;
293 virtual Iteration *clone() const { return new Iteration(*this); }
294 virtual void visit(NodeVisitor &);
297 struct Passthrough: Node
299 NodePtr<Expression> subscript;
301 virtual Passthrough *clone() const { return new Passthrough(*this); }
302 virtual void visit(NodeVisitor &);
307 NodePtr<Expression> expression;
309 virtual Return *clone() const { return new Return(*this); }
310 virtual void visit(NodeVisitor &);
317 virtual Jump *clone() const { return new Jump(*this); }
318 virtual void visit(NodeVisitor &);
323 virtual ~NodeVisitor() { }
325 virtual void visit(Block &) { }
326 virtual void visit(Literal &) { }
327 virtual void visit(ParenthesizedExpression &) { }
328 virtual void visit(VariableReference &) { }
329 virtual void visit(MemberAccess &) { }
330 virtual void visit(UnaryExpression &) { }
331 virtual void visit(BinaryExpression &) { }
332 virtual void visit(Assignment &);
333 virtual void visit(FunctionCall &) { }
334 virtual void visit(ExpressionStatement &) { }
335 virtual void visit(Import &) { }
336 virtual void visit(Precision &) { }
337 virtual void visit(Layout &) { }
338 virtual void visit(InterfaceLayout &) { }
339 virtual void visit(StructDeclaration &) { }
340 virtual void visit(VariableDeclaration &) { }
341 virtual void visit(InterfaceBlock &) { }
342 virtual void visit(FunctionDeclaration &) { }
343 virtual void visit(Conditional &) { }
344 virtual void visit(Iteration &) { }
345 virtual void visit(Passthrough &) { }
346 virtual void visit(Return &) { }
347 virtual void visit(Jump &) { }
350 struct TraversingVisitor: NodeVisitor
352 using NodeVisitor::visit;
353 virtual void visit(Block &);
354 virtual void visit(ParenthesizedExpression &);
355 virtual void visit(MemberAccess &);
356 virtual void visit(UnaryExpression &);
357 virtual void visit(BinaryExpression &);
358 virtual void visit(FunctionCall &);
359 virtual void visit(ExpressionStatement &);
360 virtual void visit(InterfaceLayout &);
361 virtual void visit(StructDeclaration &);
362 virtual void visit(VariableDeclaration &);
363 virtual void visit(InterfaceBlock &);
364 virtual void visit(FunctionDeclaration &);
365 virtual void visit(Conditional &);
366 virtual void visit(Iteration &);
367 virtual void visit(Passthrough &);
368 virtual void visit(Return &);
383 ProgramSyntax::Block content;
384 std::map<std::string, VariableDeclaration *> in_variables;
385 std::map<std::string, VariableDeclaration *> out_variables;
386 std::map<std::string, unsigned> locations;
387 Version required_version;
395 std::list<Stage> stages;
400 } // namespace ProgramSyntax