libclang_ast.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 libclang_ast.ast.statement;
14 import libclang_ast.ast.node : Node;
15 
16 abstract class Statement : Node {
17     import clang.Cursor : Cursor;
18     import libclang_ast.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 libclang_ast.ast;
29 
30         libclang_ast.ast.accept(cursor, v);
31     }
32 }
33 
34 final class UnexposedStmt : Statement {
35     import clang.Cursor : Cursor;
36 
37     this(Cursor cursor) @safe {
38         super(cursor);
39     }
40 
41     override void accept(Visitor v) @safe const {
42         static import libclang_ast.ast;
43 
44         libclang_ast.ast.accept(cursor, v);
45     }
46 }
47 
48 final class LabelStmt : Statement {
49     import clang.Cursor : Cursor;
50 
51     this(Cursor cursor) @safe {
52         super(cursor);
53     }
54 
55     override void accept(Visitor v) @safe const {
56         static import libclang_ast.ast;
57 
58         libclang_ast.ast.accept(cursor, v);
59     }
60 }
61 
62 final class CompoundStmt : Statement {
63     import clang.Cursor : Cursor;
64 
65     this(Cursor cursor) @safe {
66         super(cursor);
67     }
68 
69     override void accept(Visitor v) @safe const {
70         static import libclang_ast.ast;
71 
72         libclang_ast.ast.accept(cursor, v);
73     }
74 }
75 
76 final class CaseStmt : Statement {
77     import clang.Cursor : Cursor;
78 
79     this(Cursor cursor) @safe {
80         super(cursor);
81     }
82 
83     override void accept(Visitor v) @safe const {
84         static import libclang_ast.ast;
85 
86         libclang_ast.ast.accept(cursor, v);
87     }
88 }
89 
90 final class DefaultStmt : Statement {
91     import clang.Cursor : Cursor;
92 
93     this(Cursor cursor) @safe {
94         super(cursor);
95     }
96 
97     override void accept(Visitor v) @safe const {
98         static import libclang_ast.ast;
99 
100         libclang_ast.ast.accept(cursor, v);
101     }
102 }
103 
104 final class IfStmt : Statement {
105     import clang.Cursor : Cursor;
106 
107     this(Cursor cursor) @safe {
108         super(cursor);
109     }
110 
111     override void accept(Visitor v) @safe const {
112         static import libclang_ast.ast;
113 
114         libclang_ast.ast.accept(cursor, v);
115     }
116 }
117 
118 final class SwitchStmt : Statement {
119     import clang.Cursor : Cursor;
120 
121     this(Cursor cursor) @safe {
122         super(cursor);
123     }
124 
125     override void accept(Visitor v) @safe const {
126         static import libclang_ast.ast;
127 
128         libclang_ast.ast.accept(cursor, v);
129     }
130 }
131 
132 final class WhileStmt : Statement {
133     import clang.Cursor : Cursor;
134 
135     this(Cursor cursor) @safe {
136         super(cursor);
137     }
138 
139     override void accept(Visitor v) @safe const {
140         static import libclang_ast.ast;
141 
142         libclang_ast.ast.accept(cursor, v);
143     }
144 }
145 
146 final class DoStmt : Statement {
147     import clang.Cursor : Cursor;
148 
149     this(Cursor cursor) @safe {
150         super(cursor);
151     }
152 
153     override void accept(Visitor v) @safe const {
154         static import libclang_ast.ast;
155 
156         libclang_ast.ast.accept(cursor, v);
157     }
158 }
159 
160 final class ForStmt : Statement {
161     import clang.Cursor : Cursor;
162 
163     this(Cursor cursor) @safe {
164         super(cursor);
165     }
166 
167     override void accept(Visitor v) @safe const {
168         static import libclang_ast.ast;
169 
170         libclang_ast.ast.accept(cursor, v);
171     }
172 }
173 
174 final class GotoStmt : Statement {
175     import clang.Cursor : Cursor;
176 
177     this(Cursor cursor) @safe {
178         super(cursor);
179     }
180 
181     override void accept(Visitor v) @safe const {
182         static import libclang_ast.ast;
183 
184         libclang_ast.ast.accept(cursor, v);
185     }
186 }
187 
188 final class IndirectGotoStmt : Statement {
189     import clang.Cursor : Cursor;
190 
191     this(Cursor cursor) @safe {
192         super(cursor);
193     }
194 
195     override void accept(Visitor v) @safe const {
196         static import libclang_ast.ast;
197 
198         libclang_ast.ast.accept(cursor, v);
199     }
200 }
201 
202 final class ContinueStmt : Statement {
203     import clang.Cursor : Cursor;
204 
205     this(Cursor cursor) @safe {
206         super(cursor);
207     }
208 
209     override void accept(Visitor v) @safe const {
210         static import libclang_ast.ast;
211 
212         libclang_ast.ast.accept(cursor, v);
213     }
214 }
215 
216 final class BreakStmt : Statement {
217     import clang.Cursor : Cursor;
218 
219     this(Cursor cursor) @safe {
220         super(cursor);
221     }
222 
223     override void accept(Visitor v) @safe const {
224         static import libclang_ast.ast;
225 
226         libclang_ast.ast.accept(cursor, v);
227     }
228 }
229 
230 final class ReturnStmt : Statement {
231     import clang.Cursor : Cursor;
232 
233     this(Cursor cursor) @safe {
234         super(cursor);
235     }
236 
237     override void accept(Visitor v) @safe const {
238         static import libclang_ast.ast;
239 
240         libclang_ast.ast.accept(cursor, v);
241     }
242 }
243 
244 final class AsmStmt : Statement {
245     import clang.Cursor : Cursor;
246 
247     this(Cursor cursor) @safe {
248         super(cursor);
249     }
250 
251     override void accept(Visitor v) @safe const {
252         static import libclang_ast.ast;
253 
254         libclang_ast.ast.accept(cursor, v);
255     }
256 }
257 
258 final class ObjCAtTryStmt : Statement {
259     import clang.Cursor : Cursor;
260 
261     this(Cursor cursor) @safe {
262         super(cursor);
263     }
264 
265     override void accept(Visitor v) @safe const {
266         static import libclang_ast.ast;
267 
268         libclang_ast.ast.accept(cursor, v);
269     }
270 }
271 
272 final class ObjCAtCatchStmt : Statement {
273     import clang.Cursor : Cursor;
274 
275     this(Cursor cursor) @safe {
276         super(cursor);
277     }
278 
279     override void accept(Visitor v) @safe const {
280         static import libclang_ast.ast;
281 
282         libclang_ast.ast.accept(cursor, v);
283     }
284 }
285 
286 final class ObjCAtFinallyStmt : Statement {
287     import clang.Cursor : Cursor;
288 
289     this(Cursor cursor) @safe {
290         super(cursor);
291     }
292 
293     override void accept(Visitor v) @safe const {
294         static import libclang_ast.ast;
295 
296         libclang_ast.ast.accept(cursor, v);
297     }
298 }
299 
300 final class ObjCAtThrowStmt : Statement {
301     import clang.Cursor : Cursor;
302 
303     this(Cursor cursor) @safe {
304         super(cursor);
305     }
306 
307     override void accept(Visitor v) @safe const {
308         static import libclang_ast.ast;
309 
310         libclang_ast.ast.accept(cursor, v);
311     }
312 }
313 
314 final class ObjCAtSynchronizedStmt : Statement {
315     import clang.Cursor : Cursor;
316 
317     this(Cursor cursor) @safe {
318         super(cursor);
319     }
320 
321     override void accept(Visitor v) @safe const {
322         static import libclang_ast.ast;
323 
324         libclang_ast.ast.accept(cursor, v);
325     }
326 }
327 
328 final class ObjCAutoreleasePoolStmt : Statement {
329     import clang.Cursor : Cursor;
330 
331     this(Cursor cursor) @safe {
332         super(cursor);
333     }
334 
335     override void accept(Visitor v) @safe const {
336         static import libclang_ast.ast;
337 
338         libclang_ast.ast.accept(cursor, v);
339     }
340 }
341 
342 final class ObjCForCollectionStmt : Statement {
343     import clang.Cursor : Cursor;
344 
345     this(Cursor cursor) @safe {
346         super(cursor);
347     }
348 
349     override void accept(Visitor v) @safe const {
350         static import libclang_ast.ast;
351 
352         libclang_ast.ast.accept(cursor, v);
353     }
354 }
355 
356 final class CxxCatchStmt : Statement {
357     import clang.Cursor : Cursor;
358 
359     this(Cursor cursor) @safe {
360         super(cursor);
361     }
362 
363     override void accept(Visitor v) @safe const {
364         static import libclang_ast.ast;
365 
366         libclang_ast.ast.accept(cursor, v);
367     }
368 }
369 
370 final class CxxTryStmt : Statement {
371     import clang.Cursor : Cursor;
372 
373     this(Cursor cursor) @safe {
374         super(cursor);
375     }
376 
377     override void accept(Visitor v) @safe const {
378         static import libclang_ast.ast;
379 
380         libclang_ast.ast.accept(cursor, v);
381     }
382 }
383 
384 final class CxxForRangeStmt : Statement {
385     import clang.Cursor : Cursor;
386 
387     this(Cursor cursor) @safe {
388         super(cursor);
389     }
390 
391     override void accept(Visitor v) @safe const {
392         static import libclang_ast.ast;
393 
394         libclang_ast.ast.accept(cursor, v);
395     }
396 }
397 
398 final class SehTryStmt : Statement {
399     import clang.Cursor : Cursor;
400 
401     this(Cursor cursor) @safe {
402         super(cursor);
403     }
404 
405     override void accept(Visitor v) @safe const {
406         static import libclang_ast.ast;
407 
408         libclang_ast.ast.accept(cursor, v);
409     }
410 }
411 
412 final class SehExceptStmt : Statement {
413     import clang.Cursor : Cursor;
414 
415     this(Cursor cursor) @safe {
416         super(cursor);
417     }
418 
419     override void accept(Visitor v) @safe const {
420         static import libclang_ast.ast;
421 
422         libclang_ast.ast.accept(cursor, v);
423     }
424 }
425 
426 final class SehFinallyStmt : Statement {
427     import clang.Cursor : Cursor;
428 
429     this(Cursor cursor) @safe {
430         super(cursor);
431     }
432 
433     override void accept(Visitor v) @safe const {
434         static import libclang_ast.ast;
435 
436         libclang_ast.ast.accept(cursor, v);
437     }
438 }
439 
440 final class MsAsmStmt : Statement {
441     import clang.Cursor : Cursor;
442 
443     this(Cursor cursor) @safe {
444         super(cursor);
445     }
446 
447     override void accept(Visitor v) @safe const {
448         static import libclang_ast.ast;
449 
450         libclang_ast.ast.accept(cursor, v);
451     }
452 }
453 
454 final class NullStmt : Statement {
455     import clang.Cursor : Cursor;
456 
457     this(Cursor cursor) @safe {
458         super(cursor);
459     }
460 
461     override void accept(Visitor v) @safe const {
462         static import libclang_ast.ast;
463 
464         libclang_ast.ast.accept(cursor, v);
465     }
466 }
467 
468 final class DeclStmt : Statement {
469     import clang.Cursor : Cursor;
470 
471     this(Cursor cursor) @safe {
472         super(cursor);
473     }
474 
475     override void accept(Visitor v) @safe const {
476         static import libclang_ast.ast;
477 
478         libclang_ast.ast.accept(cursor, v);
479     }
480 }
481 
482 final class SehLeaveStmt : Statement {
483     import clang.Cursor : Cursor;
484 
485     this(Cursor cursor) @safe {
486         super(cursor);
487     }
488 
489     override void accept(Visitor v) @safe const {
490         static import libclang_ast.ast;
491 
492         libclang_ast.ast.accept(cursor, v);
493     }
494 }