cpptooling.analyzer.clang.ast.statement source code

1 /**
2 Copyright: Copyright (c) 2016, Joakim Brännström. All rights reserved.
3 License: MPL-2
4 Author: Joakim Brännström (joakim.brannstrom@gmx.com)
5 
6 This Source Code Form is subject to the terms of the Mozilla Public License,
7 v.2.0. If a copy of the MPL was not distributed with this file, You can obtain
8 one at http://mozilla.org/MPL/2.0/.
9 
10 DO NOT EDIT. THIS FILE IS GENERATED.
11 See the generator script source/devtool/generator_clang_ast_nodes.d
12 */
13 module cpptooling.analyzer.clang.ast.statement;
14 import cpptooling.analyzer.clang.ast.node : Node;
15 
16 abstract class Statement : Node {
17     import clang.Cursor : Cursor;
18     import cpptooling.analyzer.clang.ast : Visitor;
19 
20     Cursor cursor;
21     alias cursor this;
22 
23     this(Cursor cursor) @safe {
24         this.cursor = cursor;
25     }
26 
27     override void accept(Visitor v) @safe const {
28         static import cpptooling.analyzer.clang.ast;
29         cpptooling.analyzer.clang.ast.accept(cursor, v);
30     }
31 }
32 
33 
34 final class UnexposedStmt : Statement {
35     import clang.Cursor : Cursor;
36     this(Cursor cursor) @safe {
37         super(cursor);
38     }
39 
40     override void accept(Visitor v) @safe const {
41         static import cpptooling.analyzer.clang.ast;
42         cpptooling.analyzer.clang.ast.accept(cursor, v);
43     }
44 }
45 
46 final class LabelStmt : Statement {
47     import clang.Cursor : Cursor;
48     this(Cursor cursor) @safe {
49         super(cursor);
50     }
51 
52     override void accept(Visitor v) @safe const {
53         static import cpptooling.analyzer.clang.ast;
54         cpptooling.analyzer.clang.ast.accept(cursor, v);
55     }
56 }
57 
58 final class CompoundStmt : Statement {
59     import clang.Cursor : Cursor;
60     this(Cursor cursor) @safe {
61         super(cursor);
62     }
63 
64     override void accept(Visitor v) @safe const {
65         static import cpptooling.analyzer.clang.ast;
66         cpptooling.analyzer.clang.ast.accept(cursor, v);
67     }
68 }
69 
70 final class CaseStmt : Statement {
71     import clang.Cursor : Cursor;
72     this(Cursor cursor) @safe {
73         super(cursor);
74     }
75 
76     override void accept(Visitor v) @safe const {
77         static import cpptooling.analyzer.clang.ast;
78         cpptooling.analyzer.clang.ast.accept(cursor, v);
79     }
80 }
81 
82 final class DefaultStmt : Statement {
83     import clang.Cursor : Cursor;
84     this(Cursor cursor) @safe {
85         super(cursor);
86     }
87 
88     override void accept(Visitor v) @safe const {
89         static import cpptooling.analyzer.clang.ast;
90         cpptooling.analyzer.clang.ast.accept(cursor, v);
91     }
92 }
93 
94 final class IfStmt : Statement {
95     import clang.Cursor : Cursor;
96     this(Cursor cursor) @safe {
97         super(cursor);
98     }
99 
100     override void accept(Visitor v) @safe const {
101         static import cpptooling.analyzer.clang.ast;
102         cpptooling.analyzer.clang.ast.accept(cursor, v);
103     }
104 }
105 
106 final class SwitchStmt : Statement {
107     import clang.Cursor : Cursor;
108     this(Cursor cursor) @safe {
109         super(cursor);
110     }
111 
112     override void accept(Visitor v) @safe const {
113         static import cpptooling.analyzer.clang.ast;
114         cpptooling.analyzer.clang.ast.accept(cursor, v);
115     }
116 }
117 
118 final class WhileStmt : Statement {
119     import clang.Cursor : Cursor;
120     this(Cursor cursor) @safe {
121         super(cursor);
122     }
123 
124     override void accept(Visitor v) @safe const {
125         static import cpptooling.analyzer.clang.ast;
126         cpptooling.analyzer.clang.ast.accept(cursor, v);
127     }
128 }
129 
130 final class DoStmt : Statement {
131     import clang.Cursor : Cursor;
132     this(Cursor cursor) @safe {
133         super(cursor);
134     }
135 
136     override void accept(Visitor v) @safe const {
137         static import cpptooling.analyzer.clang.ast;
138         cpptooling.analyzer.clang.ast.accept(cursor, v);
139     }
140 }
141 
142 final class ForStmt : Statement {
143     import clang.Cursor : Cursor;
144     this(Cursor cursor) @safe {
145         super(cursor);
146     }
147 
148     override void accept(Visitor v) @safe const {
149         static import cpptooling.analyzer.clang.ast;
150         cpptooling.analyzer.clang.ast.accept(cursor, v);
151     }
152 }
153 
154 final class GotoStmt : Statement {
155     import clang.Cursor : Cursor;
156     this(Cursor cursor) @safe {
157         super(cursor);
158     }
159 
160     override void accept(Visitor v) @safe const {
161         static import cpptooling.analyzer.clang.ast;
162         cpptooling.analyzer.clang.ast.accept(cursor, v);
163     }
164 }
165 
166 final class IndirectGotoStmt : Statement {
167     import clang.Cursor : Cursor;
168     this(Cursor cursor) @safe {
169         super(cursor);
170     }
171 
172     override void accept(Visitor v) @safe const {
173         static import cpptooling.analyzer.clang.ast;
174         cpptooling.analyzer.clang.ast.accept(cursor, v);
175     }
176 }
177 
178 final class ContinueStmt : Statement {
179     import clang.Cursor : Cursor;
180     this(Cursor cursor) @safe {
181         super(cursor);
182     }
183 
184     override void accept(Visitor v) @safe const {
185         static import cpptooling.analyzer.clang.ast;
186         cpptooling.analyzer.clang.ast.accept(cursor, v);
187     }
188 }
189 
190 final class BreakStmt : Statement {
191     import clang.Cursor : Cursor;
192     this(Cursor cursor) @safe {
193         super(cursor);
194     }
195 
196     override void accept(Visitor v) @safe const {
197         static import cpptooling.analyzer.clang.ast;
198         cpptooling.analyzer.clang.ast.accept(cursor, v);
199     }
200 }
201 
202 final class ReturnStmt : Statement {
203     import clang.Cursor : Cursor;
204     this(Cursor cursor) @safe {
205         super(cursor);
206     }
207 
208     override void accept(Visitor v) @safe const {
209         static import cpptooling.analyzer.clang.ast;
210         cpptooling.analyzer.clang.ast.accept(cursor, v);
211     }
212 }
213 
214 final class AsmStmt : Statement {
215     import clang.Cursor : Cursor;
216     this(Cursor cursor) @safe {
217         super(cursor);
218     }
219 
220     override void accept(Visitor v) @safe const {
221         static import cpptooling.analyzer.clang.ast;
222         cpptooling.analyzer.clang.ast.accept(cursor, v);
223     }
224 }
225 
226 final class ObjCAtTryStmt : Statement {
227     import clang.Cursor : Cursor;
228     this(Cursor cursor) @safe {
229         super(cursor);
230     }
231 
232     override void accept(Visitor v) @safe const {
233         static import cpptooling.analyzer.clang.ast;
234         cpptooling.analyzer.clang.ast.accept(cursor, v);
235     }
236 }
237 
238 final class ObjCAtCatchStmt : Statement {
239     import clang.Cursor : Cursor;
240     this(Cursor cursor) @safe {
241         super(cursor);
242     }
243 
244     override void accept(Visitor v) @safe const {
245         static import cpptooling.analyzer.clang.ast;
246         cpptooling.analyzer.clang.ast.accept(cursor, v);
247     }
248 }
249 
250 final class ObjCAtFinallyStmt : Statement {
251     import clang.Cursor : Cursor;
252     this(Cursor cursor) @safe {
253         super(cursor);
254     }
255 
256     override void accept(Visitor v) @safe const {
257         static import cpptooling.analyzer.clang.ast;
258         cpptooling.analyzer.clang.ast.accept(cursor, v);
259     }
260 }
261 
262 final class ObjCAtThrowStmt : Statement {
263     import clang.Cursor : Cursor;
264     this(Cursor cursor) @safe {
265         super(cursor);
266     }
267 
268     override void accept(Visitor v) @safe const {
269         static import cpptooling.analyzer.clang.ast;
270         cpptooling.analyzer.clang.ast.accept(cursor, v);
271     }
272 }
273 
274 final class ObjCAtSynchronizedStmt : Statement {
275     import clang.Cursor : Cursor;
276     this(Cursor cursor) @safe {
277         super(cursor);
278     }
279 
280     override void accept(Visitor v) @safe const {
281         static import cpptooling.analyzer.clang.ast;
282         cpptooling.analyzer.clang.ast.accept(cursor, v);
283     }
284 }
285 
286 final class ObjCAutoreleasePoolStmt : Statement {
287     import clang.Cursor : Cursor;
288     this(Cursor cursor) @safe {
289         super(cursor);
290     }
291 
292     override void accept(Visitor v) @safe const {
293         static import cpptooling.analyzer.clang.ast;
294         cpptooling.analyzer.clang.ast.accept(cursor, v);
295     }
296 }
297 
298 final class ObjCForCollectionStmt : Statement {
299     import clang.Cursor : Cursor;
300     this(Cursor cursor) @safe {
301         super(cursor);
302     }
303 
304     override void accept(Visitor v) @safe const {
305         static import cpptooling.analyzer.clang.ast;
306         cpptooling.analyzer.clang.ast.accept(cursor, v);
307     }
308 }
309 
310 final class CxxCatchStmt : Statement {
311     import clang.Cursor : Cursor;
312     this(Cursor cursor) @safe {
313         super(cursor);
314     }
315 
316     override void accept(Visitor v) @safe const {
317         static import cpptooling.analyzer.clang.ast;
318         cpptooling.analyzer.clang.ast.accept(cursor, v);
319     }
320 }
321 
322 final class CxxTryStmt : Statement {
323     import clang.Cursor : Cursor;
324     this(Cursor cursor) @safe {
325         super(cursor);
326     }
327 
328     override void accept(Visitor v) @safe const {
329         static import cpptooling.analyzer.clang.ast;
330         cpptooling.analyzer.clang.ast.accept(cursor, v);
331     }
332 }
333 
334 final class CxxForRangeStmt : Statement {
335     import clang.Cursor : Cursor;
336     this(Cursor cursor) @safe {
337         super(cursor);
338     }
339 
340     override void accept(Visitor v) @safe const {
341         static import cpptooling.analyzer.clang.ast;
342         cpptooling.analyzer.clang.ast.accept(cursor, v);
343     }
344 }
345 
346 final class SehTryStmt : Statement {
347     import clang.Cursor : Cursor;
348     this(Cursor cursor) @safe {
349         super(cursor);
350     }
351 
352     override void accept(Visitor v) @safe const {
353         static import cpptooling.analyzer.clang.ast;
354         cpptooling.analyzer.clang.ast.accept(cursor, v);
355     }
356 }
357 
358 final class SehExceptStmt : Statement {
359     import clang.Cursor : Cursor;
360     this(Cursor cursor) @safe {
361         super(cursor);
362     }
363 
364     override void accept(Visitor v) @safe const {
365         static import cpptooling.analyzer.clang.ast;
366         cpptooling.analyzer.clang.ast.accept(cursor, v);
367     }
368 }
369 
370 final class SehFinallyStmt : Statement {
371     import clang.Cursor : Cursor;
372     this(Cursor cursor) @safe {
373         super(cursor);
374     }
375 
376     override void accept(Visitor v) @safe const {
377         static import cpptooling.analyzer.clang.ast;
378         cpptooling.analyzer.clang.ast.accept(cursor, v);
379     }
380 }
381 
382 final class MsAsmStmt : Statement {
383     import clang.Cursor : Cursor;
384     this(Cursor cursor) @safe {
385         super(cursor);
386     }
387 
388     override void accept(Visitor v) @safe const {
389         static import cpptooling.analyzer.clang.ast;
390         cpptooling.analyzer.clang.ast.accept(cursor, v);
391     }
392 }
393 
394 final class NullStmt : Statement {
395     import clang.Cursor : Cursor;
396     this(Cursor cursor) @safe {
397         super(cursor);
398     }
399 
400     override void accept(Visitor v) @safe const {
401         static import cpptooling.analyzer.clang.ast;
402         cpptooling.analyzer.clang.ast.accept(cursor, v);
403     }
404 }
405 
406 final class DeclStmt : Statement {
407     import clang.Cursor : Cursor;
408     this(Cursor cursor) @safe {
409         super(cursor);
410     }
411 
412     override void accept(Visitor v) @safe const {
413         static import cpptooling.analyzer.clang.ast;
414         cpptooling.analyzer.clang.ast.accept(cursor, v);
415     }
416 }
417 
418 final class SehLeaveStmt : Statement {
419     import clang.Cursor : Cursor;
420     this(Cursor cursor) @safe {
421         super(cursor);
422     }
423 
424     override void accept(Visitor v) @safe const {
425         static import cpptooling.analyzer.clang.ast;
426         cpptooling.analyzer.clang.ast.accept(cursor, v);
427     }
428 }
429