]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/visitor.h
Minor, largely cosmetic tweaks
[libs/gl.git] / source / glsl / visitor.h
1 #ifndef MSP_GL_SL_VISITOR_H_
2 #define MSP_GL_SL_VISITOR_H_
3
4 #include <set>
5 #include <vector>
6 #include "syntax.h"
7
8 namespace Msp {
9 namespace GL {
10 namespace SL {
11
12 /** Base class for all node visitors. */
13 class NodeVisitor
14 {
15 protected:
16         NodeVisitor() { }
17 public:
18         virtual ~NodeVisitor() { }
19
20         virtual void visit(Block &) { }
21         virtual void visit(Literal &) { }
22         virtual void visit(ParenthesizedExpression &) { }
23         virtual void visit(VariableReference &) { }
24         virtual void visit(InterfaceBlockReference &) { }
25         virtual void visit(MemberAccess &) { }
26         virtual void visit(UnaryExpression &) { }
27         virtual void visit(BinaryExpression &) { }
28         virtual void visit(Assignment &) { }
29         virtual void visit(FunctionCall &) { }
30         virtual void visit(ExpressionStatement &) { }
31         virtual void visit(Import &) { }
32         virtual void visit(Precision &) { }
33         virtual void visit(Layout &) { }
34         virtual void visit(InterfaceLayout &) { }
35         virtual void visit(StructDeclaration &) { }
36         virtual void visit(VariableDeclaration &) { }
37         virtual void visit(InterfaceBlock &) { }
38         virtual void visit(FunctionDeclaration &) { }
39         virtual void visit(Conditional &) { }
40         virtual void visit(Iteration &) { }
41         virtual void visit(Passthrough &) { }
42         virtual void visit(Return &) { }
43         virtual void visit(Jump &) { }
44 };
45
46 /** An intermediate base visitor class which traverses the syntax tree. */
47 class TraversingVisitor: public NodeVisitor
48 {
49 protected:
50         Block *current_block;
51
52         TraversingVisitor(): current_block(0) { }
53
54 public:
55         virtual void enter(Block &) { }
56         virtual void visit(Block &);
57         virtual void visit(ParenthesizedExpression &);
58         virtual void visit(MemberAccess &);
59         virtual void visit(UnaryExpression &);
60         virtual void visit(BinaryExpression &);
61         virtual void visit(Assignment &);
62         virtual void visit(FunctionCall &);
63         virtual void visit(ExpressionStatement &);
64         virtual void visit(InterfaceLayout &);
65         virtual void visit(StructDeclaration &);
66         virtual void visit(VariableDeclaration &);
67         virtual void visit(InterfaceBlock &);
68         virtual void visit(FunctionDeclaration &);
69         virtual void visit(Conditional &);
70         virtual void visit(Iteration &);
71         virtual void visit(Passthrough &);
72         virtual void visit(Return &);
73 };
74
75 /** Gathers nodes of a particular type from the syntax tree. */
76 template<typename T>
77 class NodeGatherer: private TraversingVisitor
78 {
79 private:
80         std::vector<T *> nodes;
81
82 public:
83         const std::vector<T *> &apply(Stage &s) { s.content.visit(*this); return nodes; }
84
85 private:
86         virtual void visit(T &n) { nodes.push_back(&n); }
87 };
88
89 /** Removes a set of nodes from the syntax tree. */
90 class NodeRemover: private TraversingVisitor
91 {
92 private:
93         Stage *stage;
94         const std::set<Node *> *to_remove;
95         bool recursive_remove;
96
97 public:
98         NodeRemover();
99
100         void apply(Stage &, const std::set<Node *> &);
101
102 private:
103         template<typename T>
104         void remove_from_map(std::map<std::string, T *> &, const std::string &, T &);
105
106         virtual void visit(Block &);
107         virtual void visit(StructDeclaration &);
108         virtual void visit(VariableDeclaration &);
109         virtual void visit(InterfaceBlock &);
110         virtual void visit(FunctionDeclaration &);
111         virtual void visit(Iteration &);
112 };
113
114 /** Reorders a set of nodes so they appear before another node.  Only nodes
115 on the same hierarchly level as the target node are reordered. */
116 class NodeReorderer: private TraversingVisitor
117 {
118 private:
119         Node *reorder_before;
120         const std::set<Node *> *to_reorder;
121
122 public:
123         NodeReorderer();
124
125         void apply(Stage &, Node &, const std::set<Node *> &);
126
127 private:
128         virtual void visit(Block &);
129 };
130
131 } // namespace SL
132 } // namespace GL
133 } // namespace Msp
134
135 #endif