1 #ifndef MSP_GL_PROGRAMSYNTAX_H_
2 #define MSP_GL_PROGRAMSYNTAX_H_
12 namespace ProgramSyntax {
19 Node &operator=(const Node &);
23 virtual Node *clone() const = 0;
24 virtual void visit(NodeVisitor &) = 0;
34 NodePtr(T *n = 0): node(n) { }
35 NodePtr(const NodePtr &p): node(clone(p.node)) { }
36 NodePtr &operator=(const NodePtr &p) { delete node; node = clone(p.node); return *this; }
37 #if __cplusplus>=201103L
38 NodePtr(NodePtr &&p): node(p.node) { p.node = 0; }
39 NodePtr &operator=(NodePtr &&p) { delete node; node = p.node; p.node = 0; return *this; }
41 ~NodePtr() { delete node; }
44 static T *clone(T *n) { return n ? n->clone() : 0; }
47 T *operator->() { return node; }
48 const T *operator->() const { return node; }
49 T &operator*() { return *node; }
50 const T &operator*() const { return *node; }
51 operator void *() const { return node; }
54 struct StructDeclaration;
55 struct VariableDeclaration;
56 struct FunctionDeclaration;
60 std::list<NodePtr<Node> > body;
62 std::map<std::string, StructDeclaration *> types;
63 std::map<std::string, VariableDeclaration *> variables;
67 virtual Block *clone() const { return new Block(*this); }
68 virtual void visit(NodeVisitor &);
71 struct Expression: Node
73 virtual Expression *clone() const = 0;
76 struct Literal: Expression
80 virtual Literal *clone() const { return new Literal(*this); }
81 virtual void visit(NodeVisitor &);
84 struct ParenthesizedExpression: Expression
86 NodePtr<Expression> expression;
88 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
89 virtual void visit(NodeVisitor &);
92 struct VariableReference: Expression
95 VariableDeclaration *declaration;
99 virtual VariableReference *clone() const { return new VariableReference(*this); }
100 virtual void visit(NodeVisitor &);
103 struct MemberAccess: Expression
105 NodePtr<Expression> left;
107 VariableDeclaration *declaration;
109 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
110 virtual void visit(NodeVisitor &);
113 struct UnaryExpression: Expression
116 NodePtr<Expression> expression;
121 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
122 virtual void visit(NodeVisitor &);
125 struct BinaryExpression: Expression
127 NodePtr<Expression> left;
129 NodePtr<Expression> right;
132 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
133 virtual void visit(NodeVisitor &);
136 struct Assignment: BinaryExpression
138 bool self_referencing;
139 VariableDeclaration *target_declaration;
143 virtual Assignment *clone() const { return new Assignment(*this); }
144 virtual void visit(NodeVisitor &);
147 struct FunctionCall: Expression
150 FunctionDeclaration *declaration;
152 std::vector<NodePtr<Expression> > arguments;
156 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
157 virtual void visit(NodeVisitor &);
160 struct ExpressionStatement: Node
162 NodePtr<Expression> expression;
164 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
165 virtual void visit(NodeVisitor &);
172 virtual Import *clone() const { return new Import(*this); }
173 virtual void visit(NodeVisitor &);
180 std::string identifier;
184 std::vector<Qualifier> qualifiers;
186 virtual Layout *clone() const { return new Layout(*this); }
187 virtual void visit(NodeVisitor &);
190 struct InterfaceLayout: Node
192 std::string interface;
195 virtual InterfaceLayout *clone() const { return new InterfaceLayout(*this); }
196 virtual void visit(NodeVisitor &);
199 struct StructDeclaration: Node
206 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
207 virtual void visit(NodeVisitor &);
210 struct VariableDeclaration: Node
213 std::string sampling;
214 std::string interface;
216 StructDeclaration *type_declaration;
219 NodePtr<Expression> array_size;
220 NodePtr<Expression> init_expression;
221 VariableDeclaration *linked_declaration;
222 NodePtr<Layout> layout;
224 VariableDeclaration();
226 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
227 virtual void visit(NodeVisitor &);
230 struct InterfaceBlock: Node
232 std::string interface;
235 std::string instance_name;
240 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
241 virtual void visit(NodeVisitor &);
244 struct FunctionDeclaration: Node
246 std::string return_type;
248 std::vector<NodePtr<VariableDeclaration> > parameters;
249 FunctionDeclaration *definition;
252 FunctionDeclaration();
253 FunctionDeclaration(const FunctionDeclaration &);
255 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
256 virtual void visit(NodeVisitor &);
259 struct Conditional: Node
261 NodePtr<Expression> condition;
265 virtual Conditional *clone() const { return new Conditional(*this); }
266 virtual void visit(NodeVisitor &);
269 struct Iteration: Node
271 NodePtr<Node> init_statement;
272 NodePtr<Expression> condition;
273 NodePtr<Expression> loop_expression;
276 virtual Iteration *clone() const { return new Iteration(*this); }
277 virtual void visit(NodeVisitor &);
280 struct Passthrough: Node
282 NodePtr<Expression> subscript;
284 virtual Passthrough *clone() const { return new Passthrough(*this); }
285 virtual void visit(NodeVisitor &);
290 NodePtr<Expression> expression;
292 virtual Return *clone() const { return new Return(*this); }
293 virtual void visit(NodeVisitor &);
298 virtual ~NodeVisitor() { }
300 virtual void visit(Block &) { }
301 virtual void visit(Literal &) { }
302 virtual void visit(ParenthesizedExpression &) { }
303 virtual void visit(VariableReference &) { }
304 virtual void visit(MemberAccess &) { }
305 virtual void visit(UnaryExpression &) { }
306 virtual void visit(BinaryExpression &) { }
307 virtual void visit(Assignment &);
308 virtual void visit(FunctionCall &) { }
309 virtual void visit(ExpressionStatement &) { }
310 virtual void visit(Import &) { }
311 virtual void visit(Layout &) { }
312 virtual void visit(InterfaceLayout &) { }
313 virtual void visit(StructDeclaration &) { }
314 virtual void visit(VariableDeclaration &) { }
315 virtual void visit(InterfaceBlock &) { }
316 virtual void visit(FunctionDeclaration &) { }
317 virtual void visit(Conditional &) { }
318 virtual void visit(Iteration &) { }
319 virtual void visit(Passthrough &) { }
320 virtual void visit(Return &) { }
323 struct TraversingVisitor: NodeVisitor
325 virtual void visit(Block &);
326 virtual void visit(ParenthesizedExpression &);
327 virtual void visit(MemberAccess &);
328 virtual void visit(UnaryExpression &);
329 virtual void visit(BinaryExpression &);
330 virtual void visit(FunctionCall &);
331 virtual void visit(ExpressionStatement &);
332 virtual void visit(InterfaceLayout &);
333 virtual void visit(StructDeclaration &);
334 virtual void visit(VariableDeclaration &);
335 virtual void visit(InterfaceBlock &);
336 virtual void visit(FunctionDeclaration &);
337 virtual void visit(Conditional &);
338 virtual void visit(Iteration &);
339 virtual void visit(Passthrough &);
340 virtual void visit(Return &);
355 ProgramSyntax::Block content;
356 std::map<std::string, VariableDeclaration *> in_variables;
357 std::map<std::string, VariableDeclaration *> out_variables;
358 std::map<std::string, unsigned> locations;
359 Version required_version;
367 std::list<Stage> stages;
372 } // namespace ProgramSyntax