1 #ifndef MSP_GL_PROGRAMSYNTAX_H_
2 #define MSP_GL_PROGRAMSYNTAX_H_
11 namespace ProgramSyntax {
18 Node &operator=(const Node &);
22 virtual Node *clone() const = 0;
23 virtual void visit(NodeVisitor &) = 0;
33 NodePtr(T *n = 0): node(n) { }
34 NodePtr(const NodePtr &p): node(clone(p.node)) { }
35 NodePtr &operator=(const NodePtr &p) { delete node; node = clone(p.node); return *this; }
36 #if __cplusplus>=201103L
37 NodePtr(NodePtr &&p): node(p.node) { p.node = 0; }
38 NodePtr &operator=(NodePtr &&p) { delete node; node = p.node; p.node = 0; return *this; }
40 ~NodePtr() { delete node; }
43 static T *clone(T *n) { return n ? n->clone() : 0; }
46 T *operator->() { return node; }
47 const T *operator->() const { return node; }
48 T &operator*() { return *node; }
49 const T &operator*() const { return *node; }
50 operator void *() const { return node; }
53 struct StructDeclaration;
54 struct VariableDeclaration;
55 struct FunctionDeclaration;
59 std::list<NodePtr<Node> > body;
61 std::map<std::string, StructDeclaration *> types;
62 std::map<std::string, VariableDeclaration *> variables;
66 virtual Block *clone() const { return new Block(*this); }
67 virtual void visit(NodeVisitor &);
70 struct Expression: Node
72 virtual Expression *clone() const = 0;
75 struct Literal: Expression
79 virtual Literal *clone() const { return new Literal(*this); }
80 virtual void visit(NodeVisitor &);
83 struct ParenthesizedExpression: Expression
85 NodePtr<Expression> expression;
87 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
88 virtual void visit(NodeVisitor &);
91 struct VariableReference: Expression
94 VariableDeclaration *declaration;
98 virtual VariableReference *clone() const { return new VariableReference(*this); }
99 virtual void visit(NodeVisitor &);
102 struct MemberAccess: Expression
104 NodePtr<Expression> left;
106 VariableDeclaration *declaration;
108 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
109 virtual void visit(NodeVisitor &);
112 struct UnaryExpression: Expression
115 NodePtr<Expression> expression;
120 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
121 virtual void visit(NodeVisitor &);
124 struct BinaryExpression: Expression
126 NodePtr<Expression> left;
128 NodePtr<Expression> right;
131 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
132 virtual void visit(NodeVisitor &);
135 struct Assignment: BinaryExpression
137 bool self_referencing;
138 VariableDeclaration *target_declaration;
142 virtual Assignment *clone() const { return new Assignment(*this); }
143 virtual void visit(NodeVisitor &);
146 struct FunctionCall: Expression
149 FunctionDeclaration *declaration;
151 std::vector<NodePtr<Expression> > arguments;
155 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
156 virtual void visit(NodeVisitor &);
159 struct ExpressionStatement: Node
161 NodePtr<Expression> expression;
163 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
164 virtual void visit(NodeVisitor &);
171 virtual Import *clone() const { return new Import(*this); }
172 virtual void visit(NodeVisitor &);
179 std::string identifier;
183 std::vector<Qualifier> qualifiers;
184 std::string interface;
186 virtual Layout *clone() const { return new Layout(*this); }
187 virtual void visit(NodeVisitor &);
190 struct StructDeclaration: Node
197 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
198 virtual void visit(NodeVisitor &);
201 struct VariableDeclaration: Node
204 std::string sampling;
205 std::string interface;
207 StructDeclaration *type_declaration;
210 NodePtr<Expression> array_size;
211 NodePtr<Expression> init_expression;
212 VariableDeclaration *linked_declaration;
214 VariableDeclaration();
216 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
217 virtual void visit(NodeVisitor &);
220 struct InterfaceBlock: Node
222 std::string interface;
225 std::string instance_name;
230 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
231 virtual void visit(NodeVisitor &);
234 struct FunctionDeclaration: Node
236 std::string return_type;
238 std::vector<NodePtr<VariableDeclaration> > parameters;
239 FunctionDeclaration *definition;
242 FunctionDeclaration();
243 FunctionDeclaration(const FunctionDeclaration &);
245 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
246 virtual void visit(NodeVisitor &);
249 struct Conditional: Node
251 NodePtr<Expression> condition;
255 virtual Conditional *clone() const { return new Conditional(*this); }
256 virtual void visit(NodeVisitor &);
259 struct Iteration: Node
261 NodePtr<Node> init_statement;
262 NodePtr<Expression> condition;
263 NodePtr<Expression> loop_expression;
266 virtual Iteration *clone() const { return new Iteration(*this); }
267 virtual void visit(NodeVisitor &);
270 struct Passthrough: Node
272 NodePtr<Expression> subscript;
274 virtual Passthrough *clone() const { return new Passthrough(*this); }
275 virtual void visit(NodeVisitor &);
280 NodePtr<Expression> expression;
282 virtual Return *clone() const { return new Return(*this); }
283 virtual void visit(NodeVisitor &);
288 virtual ~NodeVisitor() { }
290 virtual void visit(Block &) { }
291 virtual void visit(Literal &) { }
292 virtual void visit(ParenthesizedExpression &) { }
293 virtual void visit(VariableReference &) { }
294 virtual void visit(MemberAccess &) { }
295 virtual void visit(UnaryExpression &) { }
296 virtual void visit(BinaryExpression &) { }
297 virtual void visit(Assignment &);
298 virtual void visit(FunctionCall &) { }
299 virtual void visit(ExpressionStatement &) { }
300 virtual void visit(Import &) { }
301 virtual void visit(Layout &) { }
302 virtual void visit(StructDeclaration &) { }
303 virtual void visit(VariableDeclaration &) { }
304 virtual void visit(InterfaceBlock &) { }
305 virtual void visit(FunctionDeclaration &) { }
306 virtual void visit(Conditional &) { }
307 virtual void visit(Iteration &) { }
308 virtual void visit(Passthrough &) { }
309 virtual void visit(Return &) { }
312 struct TraversingVisitor: NodeVisitor
314 virtual void visit(Block &);
315 virtual void visit(ParenthesizedExpression &);
316 virtual void visit(MemberAccess &);
317 virtual void visit(UnaryExpression &);
318 virtual void visit(BinaryExpression &);
319 virtual void visit(FunctionCall &);
320 virtual void visit(ExpressionStatement &);
321 virtual void visit(StructDeclaration &);
322 virtual void visit(VariableDeclaration &);
323 virtual void visit(InterfaceBlock &);
324 virtual void visit(FunctionDeclaration &);
325 virtual void visit(Conditional &);
326 virtual void visit(Iteration &);
327 virtual void visit(Passthrough &);
328 virtual void visit(Return &);
343 ProgramSyntax::Block content;
344 std::map<std::string, VariableDeclaration *> in_variables;
345 std::map<std::string, VariableDeclaration *> out_variables;
353 std::list<Stage> stages;
358 } // namespace ProgramSyntax