cpptooling.analyzer.clang.ast.directive 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.directive;
14 import cpptooling.analyzer.clang.ast.node : Node;
15 
16 abstract class Directive : 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 OmpParallelDirective : Directive {
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 OmpSimdDirective : Directive {
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 OmpForDirective : Directive {
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 OmpSectionsDirective : Directive {
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 OmpSectionDirective : Directive {
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 OmpSingleDirective : Directive {
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 OmpParallelForDirective : Directive {
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 OmpParallelSectionsDirective : Directive {
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 OmpTaskDirective : Directive {
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 OmpMasterDirective : Directive {
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 OmpCriticalDirective : Directive {
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 OmpTaskyieldDirective : Directive {
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 OmpBarrierDirective : Directive {
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 OmpTaskwaitDirective : Directive {
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 OmpFlushDirective : Directive {
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 OmpOrderedDirective : Directive {
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 OmpAtomicDirective : Directive {
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 OmpForSimdDirective : Directive {
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 OmpParallelForSimdDirective : Directive {
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 OmpTargetDirective : Directive {
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 OmpTeamsDirective : Directive {
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 OmpTaskgroupDirective : Directive {
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 OmpCancellationPointDirective : Directive {
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 OmpCancelDirective : Directive {
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 OmpTargetDataDirective : Directive {
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 OmpTaskLoopDirective : Directive {
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 OmpTaskLoopSimdDirective : Directive {
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 OmpDistributeDirective : Directive {
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 OmpTargetEnterDataDirective : Directive {
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 OmpTargetExitDataDirective : Directive {
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 OmpTargetParallelDirective : Directive {
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 OmpTargetParallelForDirective : Directive {
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 OmpTargetUpdateDirective : Directive {
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 
430 final class OmpDistributeParallelForDirective : Directive {
431     import clang.Cursor : Cursor;
432     this(Cursor cursor) @safe {
433         super(cursor);
434     }
435 
436     override void accept(Visitor v) @safe const {
437         static import cpptooling.analyzer.clang.ast;
438         cpptooling.analyzer.clang.ast.accept(cursor, v);
439     }
440 }
441 
442 final class OmpDistributeParallelForSimdDirective : Directive {
443     import clang.Cursor : Cursor;
444     this(Cursor cursor) @safe {
445         super(cursor);
446     }
447 
448     override void accept(Visitor v) @safe const {
449         static import cpptooling.analyzer.clang.ast;
450         cpptooling.analyzer.clang.ast.accept(cursor, v);
451     }
452 }
453 
454 final class OmpDistributeSimdDirective : Directive {
455     import clang.Cursor : Cursor;
456     this(Cursor cursor) @safe {
457         super(cursor);
458     }
459 
460     override void accept(Visitor v) @safe const {
461         static import cpptooling.analyzer.clang.ast;
462         cpptooling.analyzer.clang.ast.accept(cursor, v);
463     }
464 }
465 
466 final class OmpTargetParallelForSimdDirective : Directive {
467     import clang.Cursor : Cursor;
468     this(Cursor cursor) @safe {
469         super(cursor);
470     }
471 
472     override void accept(Visitor v) @safe const {
473         static import cpptooling.analyzer.clang.ast;
474         cpptooling.analyzer.clang.ast.accept(cursor, v);
475     }
476 }
477 
478 final class OmpTargetSimdDirective : Directive {
479     import clang.Cursor : Cursor;
480     this(Cursor cursor) @safe {
481         super(cursor);
482     }
483 
484     override void accept(Visitor v) @safe const {
485         static import cpptooling.analyzer.clang.ast;
486         cpptooling.analyzer.clang.ast.accept(cursor, v);
487     }
488 }
489 
490 final class OmpTeamsDistributeDirective : Directive {
491     import clang.Cursor : Cursor;
492     this(Cursor cursor) @safe {
493         super(cursor);
494     }
495 
496     override void accept(Visitor v) @safe const {
497         static import cpptooling.analyzer.clang.ast;
498         cpptooling.analyzer.clang.ast.accept(cursor, v);
499     }
500 }
501 
502 final class OmpTeamsDistributeSimdDirective : Directive {
503     import clang.Cursor : Cursor;
504     this(Cursor cursor) @safe {
505         super(cursor);
506     }
507 
508     override void accept(Visitor v) @safe const {
509         static import cpptooling.analyzer.clang.ast;
510         cpptooling.analyzer.clang.ast.accept(cursor, v);
511     }
512 }
513 
514 final class OmpTeamsDistributeParallelForSimdDirective : Directive {
515     import clang.Cursor : Cursor;
516     this(Cursor cursor) @safe {
517         super(cursor);
518     }
519 
520     override void accept(Visitor v) @safe const {
521         static import cpptooling.analyzer.clang.ast;
522         cpptooling.analyzer.clang.ast.accept(cursor, v);
523     }
524 }
525 
526 final class OmpTeamsDistributeParallelForDirective : Directive {
527     import clang.Cursor : Cursor;
528     this(Cursor cursor) @safe {
529         super(cursor);
530     }
531 
532     override void accept(Visitor v) @safe const {
533         static import cpptooling.analyzer.clang.ast;
534         cpptooling.analyzer.clang.ast.accept(cursor, v);
535     }
536 }
537 
538 final class OmpTargetTeamsDirective : Directive {
539     import clang.Cursor : Cursor;
540     this(Cursor cursor) @safe {
541         super(cursor);
542     }
543 
544     override void accept(Visitor v) @safe const {
545         static import cpptooling.analyzer.clang.ast;
546         cpptooling.analyzer.clang.ast.accept(cursor, v);
547     }
548 }
549 
550 final class OmpTargetTeamsDistributeDirective : Directive {
551     import clang.Cursor : Cursor;
552     this(Cursor cursor) @safe {
553         super(cursor);
554     }
555 
556     override void accept(Visitor v) @safe const {
557         static import cpptooling.analyzer.clang.ast;
558         cpptooling.analyzer.clang.ast.accept(cursor, v);
559     }
560 }
561 
562 final class OmpTargetTeamsDistributeParallelForDirective : Directive {
563     import clang.Cursor : Cursor;
564     this(Cursor cursor) @safe {
565         super(cursor);
566     }
567 
568     override void accept(Visitor v) @safe const {
569         static import cpptooling.analyzer.clang.ast;
570         cpptooling.analyzer.clang.ast.accept(cursor, v);
571     }
572 }
573 
574 final class OmpTargetTeamsDistributeParallelForSimdDirective : Directive {
575     import clang.Cursor : Cursor;
576     this(Cursor cursor) @safe {
577         super(cursor);
578     }
579 
580     override void accept(Visitor v) @safe const {
581         static import cpptooling.analyzer.clang.ast;
582         cpptooling.analyzer.clang.ast.accept(cursor, v);
583     }
584 }
585 
586 final class OmpTargetTeamsDistributeSimdDirective : Directive {
587     import clang.Cursor : Cursor;
588     this(Cursor cursor) @safe {
589         super(cursor);
590     }
591 
592     override void accept(Visitor v) @safe const {
593         static import cpptooling.analyzer.clang.ast;
594         cpptooling.analyzer.clang.ast.accept(cursor, v);
595     }
596 }
597