1 | #pragma once |
---|
2 | // IWYU pragma: private, include "Common/PassVisitor.h" |
---|
3 | |
---|
4 | #include <functional> |
---|
5 | #include <list> |
---|
6 | #include <stack> |
---|
7 | |
---|
8 | #include "Fwd.hpp" |
---|
9 | #include "Node.hpp" |
---|
10 | |
---|
11 | // Private prelude header, needed for some of the magic tricks this class pulls off |
---|
12 | #include "Pass.proto.hpp" |
---|
13 | |
---|
14 | namespace ast { |
---|
15 | //------------------------------------------------------------------------------------------------- |
---|
16 | // Templated visitor type |
---|
17 | // To use declare a Pass< YOUR VISITOR TYPE > |
---|
18 | // The visitor type should specify the previsit/postvisit for types that are desired. |
---|
19 | // Note: previsit/postvisit must be **public** members |
---|
20 | // |
---|
21 | // Several additional features are available through inheritance |
---|
22 | // | WithTypeSubstitution - provides polymorphic TypeSubstitution * env for the current expression |
---|
23 | // | WithStmtsToAdd - provides the ability to insert statements before or after the current |
---|
24 | // statement by adding new statements into stmtsToAddBefore or |
---|
25 | // stmtsToAddAfter respectively. |
---|
26 | // | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children |
---|
27 | // to false in pre{visit,visit} to skip visiting children |
---|
28 | // | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, |
---|
29 | // call GuardValue with the variable to save, the variable will |
---|
30 | // automatically be restored to its previous value after the corresponding |
---|
31 | // postvisit/postmutate teminates. |
---|
32 | //------------------------------------------------------------------------------------------------- |
---|
33 | template< typename pass_t > |
---|
34 | class Pass final : public ast::Visitor { |
---|
35 | public: |
---|
36 | template< typename... Args > |
---|
37 | Pass( Args &&... args) |
---|
38 | : m_pass( std::forward<Args>( args )... ) |
---|
39 | { |
---|
40 | // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor |
---|
41 | typedef Pass<pass_t> this_t; |
---|
42 | this_t * const * visitor = __pass::visitor(m_pass, 0); |
---|
43 | if(visitor) { |
---|
44 | *const_cast<this_t **>( visitor ) = this; |
---|
45 | } |
---|
46 | } |
---|
47 | |
---|
48 | virtual ~Pass() = default; |
---|
49 | |
---|
50 | pass_t m_pass; |
---|
51 | |
---|
52 | virtual DeclWithType * visit( const ObjectDecl * ) override final; |
---|
53 | virtual DeclWithType * visit( const FunctionDecl * ) override final; |
---|
54 | virtual Decl * visit( const StructDecl * ) override final; |
---|
55 | virtual Decl * visit( const UnionDecl * ) override final; |
---|
56 | virtual Decl * visit( const EnumDecl * ) override final; |
---|
57 | virtual Decl * visit( const TraitDecl * ) override final; |
---|
58 | virtual Decl * visit( const TypeDecl * ) override final; |
---|
59 | virtual Decl * visit( const TypedefDecl * ) override final; |
---|
60 | virtual AsmDecl * visit( const AsmDecl * ) override final; |
---|
61 | virtual StaticAssertDecl * visit( const StaticAssertDecl * ) override final; |
---|
62 | virtual CompoundStmt * visit( const CompoundStmt * ) override final; |
---|
63 | virtual Stmt * visit( const ExprStmt * ) override final; |
---|
64 | virtual Stmt * visit( const AsmStmt * ) override final; |
---|
65 | virtual Stmt * visit( const DirectiveStmt * ) override final; |
---|
66 | virtual Stmt * visit( const IfStmt * ) override final; |
---|
67 | virtual Stmt * visit( const WhileStmt * ) override final; |
---|
68 | virtual Stmt * visit( const ForStmt * ) override final; |
---|
69 | virtual Stmt * visit( const SwitchStmt * ) override final; |
---|
70 | virtual Stmt * visit( const CaseStmt * ) override final; |
---|
71 | virtual Stmt * visit( const BranchStmt * ) override final; |
---|
72 | virtual Stmt * visit( const ReturnStmt * ) override final; |
---|
73 | virtual Stmt * visit( const ThrowStmt * ) override final; |
---|
74 | virtual Stmt * visit( const TryStmt * ) override final; |
---|
75 | virtual Stmt * visit( const CatchStmt * ) override final; |
---|
76 | virtual Stmt * visit( const FinallyStmt * ) override final; |
---|
77 | virtual Stmt * visit( const WaitForStmt * ) override final; |
---|
78 | virtual Stmt * visit( const WithStmt * ) override final; |
---|
79 | virtual NullStmt * visit( const NullStmt * ) override final; |
---|
80 | virtual Stmt * visit( const DeclStmt * ) override final; |
---|
81 | virtual Stmt * visit( const ImplicitCtorDtorStmt * ) override final; |
---|
82 | virtual Expr * visit( const ApplicationExpr * ) override final; |
---|
83 | virtual Expr * visit( const UntypedExpr * ) override final; |
---|
84 | virtual Expr * visit( const NameExpr * ) override final; |
---|
85 | virtual Expr * visit( const AddressExpr * ) override final; |
---|
86 | virtual Expr * visit( const LabelAddressExpr * ) override final; |
---|
87 | virtual Expr * visit( const CastExpr * ) override final; |
---|
88 | virtual Expr * visit( const KeywordCastExpr * ) override final; |
---|
89 | virtual Expr * visit( const VirtualCastExpr * ) override final; |
---|
90 | virtual Expr * visit( const UntypedMemberExpr * ) override final; |
---|
91 | virtual Expr * visit( const MemberExpr * ) override final; |
---|
92 | virtual Expr * visit( const VariableExpr * ) override final; |
---|
93 | virtual Expr * visit( const ConstantExpr * ) override final; |
---|
94 | virtual Expr * visit( const SizeofExpr * ) override final; |
---|
95 | virtual Expr * visit( const AlignofExpr * ) override final; |
---|
96 | virtual Expr * visit( const UntypedOffsetofExpr * ) override final; |
---|
97 | virtual Expr * visit( const OffsetofExpr * ) override final; |
---|
98 | virtual Expr * visit( const OffsetPackExpr * ) override final; |
---|
99 | virtual Expr * visit( const AttrExpr * ) override final; |
---|
100 | virtual Expr * visit( const LogicalExpr * ) override final; |
---|
101 | virtual Expr * visit( const ConditionalExpr * ) override final; |
---|
102 | virtual Expr * visit( const CommaExpr * ) override final; |
---|
103 | virtual Expr * visit( const TypeExpr * ) override final; |
---|
104 | virtual Expr * visit( const AsmExpr * ) override final; |
---|
105 | virtual Expr * visit( const ImplicitCopyCtorExpr * ) override final; |
---|
106 | virtual Expr * visit( const ConstructorExpr * ) override final; |
---|
107 | virtual Expr * visit( const CompoundLiteralExpr * ) override final; |
---|
108 | virtual Expr * visit( const RangeExpr * ) override final; |
---|
109 | virtual Expr * visit( const UntypedTupleExpr * ) override final; |
---|
110 | virtual Expr * visit( const TupleExpr * ) override final; |
---|
111 | virtual Expr * visit( const TupleIndexExpr * ) override final; |
---|
112 | virtual Expr * visit( const TupleAssignExpr * ) override final; |
---|
113 | virtual Expr * visit( const StmtExpr * ) override final; |
---|
114 | virtual Expr * visit( const UniqueExpr * ) override final; |
---|
115 | virtual Expr * visit( const UntypedInitExpr * ) override final; |
---|
116 | virtual Expr * visit( const InitExpr * ) override final; |
---|
117 | virtual Expr * visit( const DeletedExpr * ) override final; |
---|
118 | virtual Expr * visit( const DefaultArgExpr * ) override final; |
---|
119 | virtual Expr * visit( const GenericExpr * ) override final; |
---|
120 | virtual Type * visit( const VoidType * ) override final; |
---|
121 | virtual Type * visit( const BasicType * ) override final; |
---|
122 | virtual Type * visit( const PointerType * ) override final; |
---|
123 | virtual Type * visit( const ArrayType * ) override final; |
---|
124 | virtual Type * visit( const ReferenceType * ) override final; |
---|
125 | virtual Type * visit( const QualifiedType * ) override final; |
---|
126 | virtual Type * visit( const FunctionType * ) override final; |
---|
127 | virtual Type * visit( const StructInstType * ) override final; |
---|
128 | virtual Type * visit( const UnionInstType * ) override final; |
---|
129 | virtual Type * visit( const EnumInstType * ) override final; |
---|
130 | virtual Type * visit( const TraitInstType * ) override final; |
---|
131 | virtual Type * visit( const TypeInstType * ) override final; |
---|
132 | virtual Type * visit( const TupleType * ) override final; |
---|
133 | virtual Type * visit( const TypeofType * ) override final; |
---|
134 | virtual Type * visit( const AttrType * ) override final; |
---|
135 | virtual Type * visit( const VarArgsType * ) override final; |
---|
136 | virtual Type * visit( const ZeroType * ) override final; |
---|
137 | virtual Type * visit( const OneType * ) override final; |
---|
138 | virtual Type * visit( const GlobalScopeType * ) override final; |
---|
139 | virtual Designation * visit( const Designation * ) override final; |
---|
140 | virtual Init * visit( const SingleInit * ) override final; |
---|
141 | virtual Init * visit( const ListInit * ) override final; |
---|
142 | virtual Init * visit( const ConstructorInit * ) override final; |
---|
143 | virtual Constant * visit( const Constant * ) override final; |
---|
144 | virtual Attribute * visit( const Attribute * ) override final; |
---|
145 | virtual TypeSubstitution * visit( const TypeSubstitution * ) override final; |
---|
146 | |
---|
147 | private: |
---|
148 | |
---|
149 | bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(m_pass, 0); return ptr ? *ptr : true; } |
---|
150 | |
---|
151 | private: |
---|
152 | template<typename parent_t, typename child_t> |
---|
153 | void maybe_accept(parent_t * & , typename parent_t::child_t *); |
---|
154 | |
---|
155 | ast::Statement * call_accept( const ast::Statement * ); |
---|
156 | ast::Expression * call_accept( const ast::Expression * ); |
---|
157 | |
---|
158 | template< template <class> class container_t > |
---|
159 | container_t< ast::ptr<ast::Statement> > call_accept( const container_t< ast::ptr<ast::Statement> > & ); |
---|
160 | |
---|
161 | template< template <class> class container_t, typename node_t > |
---|
162 | container_t< ast::ptr<node_t> > call_accept( const container_t< ast::ptr<node_t> > & container ); |
---|
163 | |
---|
164 | private: |
---|
165 | struct indexer_guard { |
---|
166 | Pass<pass_t> & pass; |
---|
167 | |
---|
168 | indexer_guard( Pass<pass_t> & pass ) : pass( pass ) { __pass::indexer::enter(pass, 0); } |
---|
169 | ~indexer_guard() { __pass::indexer::leave(pass, 0); } |
---|
170 | }; |
---|
171 | |
---|
172 | indexer_guard make_indexer_guard() { return { *this }; } |
---|
173 | |
---|
174 | private: |
---|
175 | struct scope_guard { |
---|
176 | Pass<pass_t> & pass; |
---|
177 | |
---|
178 | scope_guard( Pass<pass_t> & pass ) : pass( pass ) { __pass::scope::enter(pass, 0); } |
---|
179 | ~scope_guard() { __pass::scope::leave(pass, 0); } |
---|
180 | }; |
---|
181 | |
---|
182 | scope_guard make_scope_guard() { return { *this }; } |
---|
183 | }; |
---|
184 | |
---|
185 | //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
---|
186 | // Guard value : RAII type to restore a value when the Pass finishes visiting this node |
---|
187 | template<typename pass_t, typename T> |
---|
188 | void GuardValue( pass_t * pass, T& val ) { |
---|
189 | pass->at_cleanup( [ val ]( void * newVal ) { |
---|
190 | * static_cast< T * >( newVal ) = val; |
---|
191 | }, static_cast< void * >( & val ) ); |
---|
192 | } |
---|
193 | |
---|
194 | //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
---|
195 | // PASS ACCESSORIES |
---|
196 | //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
---|
197 | |
---|
198 | // Keep track of the type substitution |
---|
199 | struct WithConstTypeSubstitution { |
---|
200 | const ast::TypeSubstitution * env = nullptr; |
---|
201 | }; |
---|
202 | |
---|
203 | template<typename T> |
---|
204 | using std_list = std::list<T>; |
---|
205 | |
---|
206 | // Used if visitor requires added statements before or after the current node. |
---|
207 | // The Pass template handles what *before* and *after* means automatically |
---|
208 | template< template<class> class container_t = std_list > |
---|
209 | struct WithStmtsToAdd { |
---|
210 | container_t< ast::ptr< ast::Statement > > stmtsToAddBefore; |
---|
211 | container_t< ast::ptr< ast::Statement > > stmtsToAddAfter; |
---|
212 | }; |
---|
213 | |
---|
214 | // Used if visitor requires added declarations before or after the current node. |
---|
215 | // The Pass template handles what *before* and *after* means automatically |
---|
216 | template< template<class> class container_t = std_list > |
---|
217 | struct WithDeclsToAdd { |
---|
218 | ~WithDeclsToAdd() { |
---|
219 | assert( declsToAddBefore.empty() ); |
---|
220 | } |
---|
221 | |
---|
222 | container_t< ast::ptr< ast::Declaration > > declsToAddBefore; |
---|
223 | container_t< ast::ptr< ast::Declaration > > declsToAddAfter; |
---|
224 | }; |
---|
225 | |
---|
226 | // Use if visitation should stop at certain levels |
---|
227 | // set visit_children false of all child nodes should be ignored |
---|
228 | struct WithShortCircuiting { |
---|
229 | __pass::bool_ref visit_children; |
---|
230 | }; |
---|
231 | |
---|
232 | // class WithGuards { |
---|
233 | // protected: |
---|
234 | // WithGuards() = default; |
---|
235 | // ~WithGuards() = default; |
---|
236 | |
---|
237 | // public: |
---|
238 | // at_cleanup_t at_cleanup; |
---|
239 | |
---|
240 | // template< typename T > |
---|
241 | // void GuardValue( T& val ) { |
---|
242 | // at_cleanup( [ val ]( void * newVal ) { |
---|
243 | // * static_cast< T * >( newVal ) = val; |
---|
244 | // }, static_cast< void * >( & val ) ); |
---|
245 | // } |
---|
246 | |
---|
247 | // template< typename T > |
---|
248 | // void GuardScope( T& val ) { |
---|
249 | // val.beginScope(); |
---|
250 | // at_cleanup( []( void * val ) { |
---|
251 | // static_cast< T * >( val )->endScope(); |
---|
252 | // }, static_cast< void * >( & val ) ); |
---|
253 | // } |
---|
254 | |
---|
255 | // template< typename Func > |
---|
256 | // void GuardAction( Func func ) { |
---|
257 | // at_cleanup( [func](__attribute__((unused)) void *) { func(); }, nullptr ); |
---|
258 | // } |
---|
259 | // }; |
---|
260 | |
---|
261 | // template<typename pass_type> |
---|
262 | // class WithVisitorRef { |
---|
263 | // protected: |
---|
264 | // WithVisitorRef() {} |
---|
265 | // ~WithVisitorRef() {} |
---|
266 | |
---|
267 | // public: |
---|
268 | // PassVisitor<pass_type> * const visitor = nullptr; |
---|
269 | // }; |
---|
270 | |
---|
271 | struct WithIndexer { |
---|
272 | SymTab::Indexer indexer; |
---|
273 | }; |
---|
274 | } |
---|