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;
58 std::list<NodePtr<Node> > body;
60 std::map<std::string, StructDeclaration *> types;
61 std::map<std::string, VariableDeclaration *> variables;
65 virtual Block *clone() const { return new Block(*this); }
66 virtual void visit(NodeVisitor &);
69 struct Expression: Node
71 virtual Expression *clone() const = 0;
74 struct Literal: Expression
78 virtual Literal *clone() const { return new Literal(*this); }
79 virtual void visit(NodeVisitor &);
82 struct ParenthesizedExpression: Expression
84 NodePtr<Expression> expression;
86 virtual ParenthesizedExpression *clone() const { return new ParenthesizedExpression(*this); }
87 virtual void visit(NodeVisitor &);
90 struct VariableReference: Expression
93 VariableDeclaration *declaration;
97 virtual VariableReference *clone() const { return new VariableReference(*this); }
98 virtual void visit(NodeVisitor &);
101 struct MemberAccess: Expression
103 NodePtr<Expression> left;
105 VariableDeclaration *declaration;
107 virtual MemberAccess *clone() const { return new MemberAccess(*this); }
108 virtual void visit(NodeVisitor &);
111 struct UnaryExpression: Expression
114 NodePtr<Expression> expression;
119 virtual UnaryExpression *clone() const { return new UnaryExpression(*this); }
120 virtual void visit(NodeVisitor &);
123 struct BinaryExpression: Expression
125 NodePtr<Expression> left;
127 NodePtr<Expression> right;
133 virtual BinaryExpression *clone() const { return new BinaryExpression(*this); }
134 virtual void visit(NodeVisitor &);
137 struct FunctionCall: Expression
141 std::vector<NodePtr<Expression> > arguments;
145 virtual FunctionCall *clone() const { return new FunctionCall(*this); }
146 virtual void visit(NodeVisitor &);
149 struct ExpressionStatement: Node
151 NodePtr<Expression> expression;
153 virtual ExpressionStatement *clone() const { return new ExpressionStatement(*this); }
154 virtual void visit(NodeVisitor &);
161 std::string identifier;
165 std::vector<Qualifier> qualifiers;
166 std::string interface;
168 virtual Layout *clone() const { return new Layout(*this); }
169 virtual void visit(NodeVisitor &);
172 struct StructDeclaration: Node
179 virtual StructDeclaration *clone() const { return new StructDeclaration(*this); }
180 virtual void visit(NodeVisitor &);
183 struct VariableDeclaration: Node
186 std::string sampling;
187 std::string interface;
189 StructDeclaration *type_declaration;
192 NodePtr<Expression> array_size;
193 NodePtr<Expression> init_expression;
194 VariableDeclaration *linked_declaration;
196 VariableDeclaration();
198 virtual VariableDeclaration *clone() const { return new VariableDeclaration(*this); }
199 virtual void visit(NodeVisitor &);
202 struct InterfaceBlock: Node
204 std::string interface;
210 virtual InterfaceBlock *clone() const { return new InterfaceBlock(*this); }
211 virtual void visit(NodeVisitor &);
214 struct FunctionDeclaration: Node
216 std::string return_type;
218 std::vector<NodePtr<VariableDeclaration> > parameters;
222 FunctionDeclaration();
224 virtual FunctionDeclaration *clone() const { return new FunctionDeclaration(*this); }
225 virtual void visit(NodeVisitor &);
228 struct Conditional: Node
230 NodePtr<Expression> condition;
234 virtual Conditional *clone() const { return new Conditional(*this); }
235 virtual void visit(NodeVisitor &);
238 struct Iteration: Node
240 NodePtr<Node> init_statement;
241 NodePtr<Expression> condition;
242 NodePtr<Expression> loop_expression;
245 virtual Iteration *clone() const { return new Iteration(*this); }
246 virtual void visit(NodeVisitor &);
249 struct Passthrough: Node
251 NodePtr<Expression> subscript;
253 virtual Passthrough *clone() const { return new Passthrough(*this); }
254 virtual void visit(NodeVisitor &);
259 NodePtr<Expression> expression;
261 virtual Return *clone() const { return new Return(*this); }
262 virtual void visit(NodeVisitor &);
267 virtual ~NodeVisitor() { }
269 virtual void visit(Block &) { }
270 virtual void visit(Literal &) { }
271 virtual void visit(ParenthesizedExpression &) { }
272 virtual void visit(VariableReference &) { }
273 virtual void visit(MemberAccess &) { }
274 virtual void visit(UnaryExpression &) { }
275 virtual void visit(BinaryExpression &) { }
276 virtual void visit(FunctionCall &) { }
277 virtual void visit(ExpressionStatement &) { }
278 virtual void visit(Layout &) { }
279 virtual void visit(StructDeclaration &) { }
280 virtual void visit(VariableDeclaration &) { }
281 virtual void visit(InterfaceBlock &) { }
282 virtual void visit(FunctionDeclaration &) { }
283 virtual void visit(Conditional &) { }
284 virtual void visit(Iteration &) { }
285 virtual void visit(Passthrough &) { }
286 virtual void visit(Return &) { }
289 struct TraversingVisitor: NodeVisitor
291 virtual void visit(Block &);
292 virtual void visit(ParenthesizedExpression &);
293 virtual void visit(MemberAccess &);
294 virtual void visit(UnaryExpression &);
295 virtual void visit(BinaryExpression &);
296 virtual void visit(FunctionCall &);
297 virtual void visit(ExpressionStatement &);
298 virtual void visit(StructDeclaration &);
299 virtual void visit(VariableDeclaration &);
300 virtual void visit(InterfaceBlock &);
301 virtual void visit(FunctionDeclaration &);
302 virtual void visit(Conditional &);
303 virtual void visit(Iteration &);
304 virtual void visit(Passthrough &);
305 virtual void visit(Return &);
320 ProgramSyntax::Block content;
321 std::map<std::string, VariableDeclaration *> in_variables;
322 std::map<std::string, VariableDeclaration *> out_variables;
330 std::list<Stage> stages;
335 } // namespace ProgramSyntax