Line data Source code
1 : /* parser/listener/visitor header section */
2 :
3 : // Generated from accparser.g4 by ANTLR 4.7.2
4 :
5 : #pragma once
6 :
7 : /* parser precinclude section */
8 :
9 : #include "antlr4-runtime.h"
10 :
11 :
12 : /* parser postinclude section */
13 : #ifndef _WIN32
14 : #pragma GCC diagnostic ignored "-Wunused-parameter"
15 : #endif
16 :
17 :
18 :
19 : /* parser context section */
20 :
21 : class accparser : public antlr4::Parser {
22 : public:
23 : enum {
24 : EXPR = 1, C_PREFIX = 2, FORTRAN_PREFIX = 3, ACC = 4, ATOMIC = 5, CACHE = 6,
25 : DATA = 7, END = 8, DECLARE = 9, ENTER = 10, EXIT = 11, HOST_DATA = 12,
26 : INIT = 13, KERNELS = 14, LOOP = 15, PARALLEL = 16, ROUTINE = 17, SERIAL = 18,
27 : SET = 19, SHUTDOWN = 20, UPDATE = 21, LEFT_PAREN = 22, RIGHT_PAREN = 23,
28 : D_BLANK = 24, COLON = 25, LINE_END = 26, ASYNC = 27, ATTACH = 28, AUTO = 29,
29 : BIND = 30, CAPTURE = 31, COLLAPSE = 32, COPY = 33, COPYIN = 34, COPYOUT = 35,
30 : CREATE = 36, DEFAULT = 37, DEFAULT_ASYNC = 38, DELETE = 39, DETACH = 40,
31 : DEVICE = 41, DEVICE_NUM = 42, DEVICE_RESIDENT = 43, DEVICE_TYPE = 44,
32 : DEVICEPTR = 45, FINALIZE = 46, FIRSTPRIVATE = 47, GANG = 48, HOST = 49,
33 : IF = 50, IF_PRESENT = 51, INDEPENDENT = 52, LINK = 53, NOHOST = 54,
34 : NO_CREATE = 55, NUM = 56, NUM_GANGS = 57, NUM_WORKERS = 58, PRESENT = 59,
35 : PRIVATE = 60, READ = 61, REDUCTION = 62, SELF = 63, SEQ = 64, TILE = 65,
36 : USE_DEVICE = 66, VECTOR = 67, VECTOR_LENGTH = 68, WAIT = 69, WORKER = 70,
37 : WRITE = 71, COMMENT = 72, CACHE_LEFT_PAREN = 73, CACHE_READONLY = 74,
38 : CACHE_COLON = 75, CACHE_COMMA = 76, CACHE_BLANK = 77, CACHE_LINE_END = 78,
39 : ROUTINE_LEFT_PAREN = 79, ROUTINE_BLANK = 80, ROUTINE_LINE_END = 81,
40 : COPYIN_LEFT_PAREN = 82, READONLY = 83, COPYIN_COLON = 84, COPYIN_COMMA = 85,
41 : COPYIN_BLANK = 86, COPYIN_LINE_END = 87, COPYOUT_LEFT_PAREN = 88, ZERO = 89,
42 : COPYOUT_COLON = 90, COPYOUT_COMMA = 91, COPYOUT_BLANK = 92, COPYOUT_LINE_END = 93,
43 : CREATE_LEFT_PAREN = 94, CREATE_ZERO = 95, CREATE_COLON = 96, CREATE_COMMA = 97,
44 : CREATE_BLANK = 98, CREATE_LINE_END = 99, NONE = 100, BLANK = 101, EXPR_LINE_END = 102,
45 : VECTOR_LEFT_PAREN = 103, LENGTH = 104, VECTOR_COLON = 105, VECTOR_BLANK = 106,
46 : VECTOR_LINE_END = 107, REDUCTION_LEFT_PAREN = 108, ADD = 109, MUL = 110,
47 : MAX = 111, MIN = 112, BITAND = 113, BITOR = 114, BITXOR = 115, LOGAND = 116,
48 : LOGOR = 117, REDUCTION_COLON = 118, REDUCTION_COMMA = 119, REDUCTION_BLANK = 120,
49 : REDUCTION_LINE_END = 121, WAIT_LEFT_PAREN = 122, DEVNUM = 123, QUEUES = 124,
50 : WAIT_COLON = 125, WAIT_COMMA = 126, WAIT_BLANK = 127, WAIT_LINE_END = 128,
51 : WORKER_LEFT_PAREN = 129, WORKER_NUM = 130, WORKER_COLON = 131, WORKER_BLANK = 132,
52 : WORKER_LINE_END = 133, EXPR_LEFT_PAREN = 134, COMMA = 135, EXPRESSION_LEFT_PAREN = 136,
53 : EXPRESSION_RIGHT_PAREN = 137, EXPRESSION_CHAR = 138
54 : };
55 :
56 : enum {
57 : RuleAcc = 0, RulePrefix = 1, RuleC_prefix = 2, RuleFortran_prefix = 3,
58 : RuleOpenacc_directive = 4, RuleAtomic_directive = 5, RuleAtomic_clause = 6,
59 : RuleCache_directive = 7, RuleCache_directive_modifier = 8, RuleData_directive = 9,
60 : RuleData_clause_list = 10, RuleData_clauses = 11, RuleDeclare_directive = 12,
61 : RuleDeclare_clause_list = 13, RuleDeclare_clauses = 14, RuleEnd_directive = 15,
62 : RuleEnd_clause_seq = 16, RuleFortran_paired_directive = 17, RuleEnd_atomic_directive = 18,
63 : RuleEnd_data_directive = 19, RuleEnd_host_data_directive = 20, RuleEnd_kernels_directive = 21,
64 : RuleEnd_kernels_loop_directive = 22, RuleEnd_parallel_directive = 23,
65 : RuleEnd_parallel_loop_directive = 24, RuleEnd_serial_directive = 25,
66 : RuleEnd_serial_loop_directive = 26, RuleEnter_data_directive = 27, RuleEnter_data_clause_list = 28,
67 : RuleEnter_data_clauses = 29, RuleExit_data_directive = 30, RuleExit_data_clause_list = 31,
68 : RuleExit_data_clauses = 32, RuleHost_data_directive = 33, RuleHost_data_clause_list = 34,
69 : RuleHost_data_clauses = 35, RuleInit_directive = 36, RuleInit_clause_list = 37,
70 : RuleInit_clauses = 38, RuleKernels_directive = 39, RuleKernels_clause_list = 40,
71 : RuleKernels_clauses = 41, RuleKernels_loop_directive = 42, RuleKernels_loop_clause_list = 43,
72 : RuleKernels_loop_clauses = 44, RuleLoop_directive = 45, RuleLoop_clause_list = 46,
73 : RuleLoop_clauses = 47, RuleParallel_directive = 48, RuleParallel_clause_list = 49,
74 : RuleParallel_clauses = 50, RuleParallel_loop_directive = 51, RuleParallel_loop_clause_list = 52,
75 : RuleParallel_loop_clauses = 53, RuleRoutine_directive = 54, RuleRoutine_clause_list = 55,
76 : RuleRoutine_clauses = 56, RuleName = 57, RuleSerial_directive = 58,
77 : RuleSerial_clause_list = 59, RuleSerial_clauses = 60, RuleSerial_loop_directive = 61,
78 : RuleSerial_loop_clause_list = 62, RuleSerial_loop_clauses = 63, RuleSet_directive = 64,
79 : RuleSet_clause_list = 65, RuleSet_clauses = 66, RuleShutdown_directive = 67,
80 : RuleShutdown_clause_list = 68, RuleShutdown_clauses = 69, RuleUpdate_directive = 70,
81 : RuleUpdate_clause_list = 71, RuleUpdate_clauses = 72, RuleWait_directive = 73,
82 : RuleWait_clause_list = 74, RuleWait_clauses = 75, RuleAsync_clause = 76,
83 : RuleAttach_clause = 77, RuleAuto_clause = 78, RuleBind_clause = 79,
84 : RuleName_or_string = 80, RuleCapture_clause = 81, RuleCollapse_clause = 82,
85 : RuleCopy_clause = 83, RuleCopyin_clause = 84, RuleCopyin_clause_modifier = 85,
86 : RuleCopyin_no_modifier_clause = 86, RuleCopyout_clause = 87, RuleCopyout_clause_modifier = 88,
87 : RuleCopyout_no_modifier_clause = 89, RuleCreate_clause = 90, RuleCreate_clause_modifier = 91,
88 : RuleCreate_no_modifier_clause = 92, RuleDefault_clause = 93, RuleDefault_kind = 94,
89 : RuleDefault_async_clause = 95, RuleDelete_clause = 96, RuleDetach_clause = 97,
90 : RuleDevice_clause = 98, RuleDevice_num_clause = 99, RuleDevice_resident_clause = 100,
91 : RuleDevice_type_clause = 101, RuleDevice_type_list = 102, RuleDeviceptr_clause = 103,
92 : RuleFinalize_clause = 104, RuleFirstprivate_clause = 105, RuleGang_clause = 106,
93 : RuleGang_arg_list = 107, RuleGang_no_list_clause = 108, RuleHost_clause = 109,
94 : RuleIf_clause = 110, RuleIf_present_clause = 111, RuleIndependent_clause = 112,
95 : RuleLink_clause = 113, RuleNohost_clause = 114, RuleNo_create_clause = 115,
96 : RuleNum_gangs_clause = 116, RuleNum_workers_clause = 117, RulePresent_clause = 118,
97 : RulePrivate_clause = 119, RuleRead_clause = 120, RuleReduction_clause = 121,
98 : RuleReduction_operator = 122, RuleSelf_clause = 123, RuleSelf_list_clause = 124,
99 : RuleCondition = 125, RuleSeq_clause = 126, RuleTile_clause = 127, RuleUpdate_clause = 128,
100 : RuleSize_expr_list = 129, RuleUse_device_clause = 130, RuleVector_clause = 131,
101 : RuleVector_clause_args = 132, RuleVector_clause_modifier = 133, RuleVector_no_modifier_clause = 134,
102 : RuleVector_length_clause = 135, RuleWait_clause = 136, RuleWait_argument_clause = 137,
103 : RuleWait_argument = 138, RuleWait_int_expr_list = 139, RuleWait_int_expr = 140,
104 : RuleWait_argument_queues = 141, RuleWait_argument_int_expr = 142, RuleWorker_clause = 143,
105 : RuleWorker_clause_args = 144, RuleWorker_clause_modifier = 145, RuleWorker_no_modifier_clause = 146,
106 : RuleWrite_clause = 147, RuleConst_int = 148, RuleInt_expr_list = 149,
107 : RuleInt_expr = 150, RuleVar_list = 151, RuleVar = 152
108 : };
109 :
110 : accparser(antlr4::TokenStream *input);
111 : ~accparser();
112 :
113 : virtual std::string getGrammarFileName() const override;
114 0 : virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
115 0 : virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
116 : virtual const std::vector<std::string>& getRuleNames() const override;
117 : virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
118 :
119 :
120 : /* public parser declarations/members section */
121 : bool myAction() { return true; }
122 : bool doesItBlend() { return true; }
123 0 : void cleanUp() {}
124 : void doInit() {}
125 : void doAfter() {}
126 :
127 :
128 : class AccContext;
129 : class PrefixContext;
130 : class C_prefixContext;
131 : class Fortran_prefixContext;
132 : class Openacc_directiveContext;
133 : class Atomic_directiveContext;
134 : class Atomic_clauseContext;
135 : class Cache_directiveContext;
136 : class Cache_directive_modifierContext;
137 : class Data_directiveContext;
138 : class Data_clause_listContext;
139 : class Data_clausesContext;
140 : class Declare_directiveContext;
141 : class Declare_clause_listContext;
142 : class Declare_clausesContext;
143 : class End_directiveContext;
144 : class End_clause_seqContext;
145 : class Fortran_paired_directiveContext;
146 : class End_atomic_directiveContext;
147 : class End_data_directiveContext;
148 : class End_host_data_directiveContext;
149 : class End_kernels_directiveContext;
150 : class End_kernels_loop_directiveContext;
151 : class End_parallel_directiveContext;
152 : class End_parallel_loop_directiveContext;
153 : class End_serial_directiveContext;
154 : class End_serial_loop_directiveContext;
155 : class Enter_data_directiveContext;
156 : class Enter_data_clause_listContext;
157 : class Enter_data_clausesContext;
158 : class Exit_data_directiveContext;
159 : class Exit_data_clause_listContext;
160 : class Exit_data_clausesContext;
161 : class Host_data_directiveContext;
162 : class Host_data_clause_listContext;
163 : class Host_data_clausesContext;
164 : class Init_directiveContext;
165 : class Init_clause_listContext;
166 : class Init_clausesContext;
167 : class Kernels_directiveContext;
168 : class Kernels_clause_listContext;
169 : class Kernels_clausesContext;
170 : class Kernels_loop_directiveContext;
171 : class Kernels_loop_clause_listContext;
172 : class Kernels_loop_clausesContext;
173 : class Loop_directiveContext;
174 : class Loop_clause_listContext;
175 : class Loop_clausesContext;
176 : class Parallel_directiveContext;
177 : class Parallel_clause_listContext;
178 : class Parallel_clausesContext;
179 : class Parallel_loop_directiveContext;
180 : class Parallel_loop_clause_listContext;
181 : class Parallel_loop_clausesContext;
182 : class Routine_directiveContext;
183 : class Routine_clause_listContext;
184 : class Routine_clausesContext;
185 : class NameContext;
186 : class Serial_directiveContext;
187 : class Serial_clause_listContext;
188 : class Serial_clausesContext;
189 : class Serial_loop_directiveContext;
190 : class Serial_loop_clause_listContext;
191 : class Serial_loop_clausesContext;
192 : class Set_directiveContext;
193 : class Set_clause_listContext;
194 : class Set_clausesContext;
195 : class Shutdown_directiveContext;
196 : class Shutdown_clause_listContext;
197 : class Shutdown_clausesContext;
198 : class Update_directiveContext;
199 : class Update_clause_listContext;
200 : class Update_clausesContext;
201 : class Wait_directiveContext;
202 : class Wait_clause_listContext;
203 : class Wait_clausesContext;
204 : class Async_clauseContext;
205 : class Attach_clauseContext;
206 : class Auto_clauseContext;
207 : class Bind_clauseContext;
208 : class Name_or_stringContext;
209 : class Capture_clauseContext;
210 : class Collapse_clauseContext;
211 : class Copy_clauseContext;
212 : class Copyin_clauseContext;
213 : class Copyin_clause_modifierContext;
214 : class Copyin_no_modifier_clauseContext;
215 : class Copyout_clauseContext;
216 : class Copyout_clause_modifierContext;
217 : class Copyout_no_modifier_clauseContext;
218 : class Create_clauseContext;
219 : class Create_clause_modifierContext;
220 : class Create_no_modifier_clauseContext;
221 : class Default_clauseContext;
222 : class Default_kindContext;
223 : class Default_async_clauseContext;
224 : class Delete_clauseContext;
225 : class Detach_clauseContext;
226 : class Device_clauseContext;
227 : class Device_num_clauseContext;
228 : class Device_resident_clauseContext;
229 : class Device_type_clauseContext;
230 : class Device_type_listContext;
231 : class Deviceptr_clauseContext;
232 : class Finalize_clauseContext;
233 : class Firstprivate_clauseContext;
234 : class Gang_clauseContext;
235 : class Gang_arg_listContext;
236 : class Gang_no_list_clauseContext;
237 : class Host_clauseContext;
238 : class If_clauseContext;
239 : class If_present_clauseContext;
240 : class Independent_clauseContext;
241 : class Link_clauseContext;
242 : class Nohost_clauseContext;
243 : class No_create_clauseContext;
244 : class Num_gangs_clauseContext;
245 : class Num_workers_clauseContext;
246 : class Present_clauseContext;
247 : class Private_clauseContext;
248 : class Read_clauseContext;
249 : class Reduction_clauseContext;
250 : class Reduction_operatorContext;
251 : class Self_clauseContext;
252 : class Self_list_clauseContext;
253 : class ConditionContext;
254 : class Seq_clauseContext;
255 : class Tile_clauseContext;
256 : class Update_clauseContext;
257 : class Size_expr_listContext;
258 : class Use_device_clauseContext;
259 : class Vector_clauseContext;
260 : class Vector_clause_argsContext;
261 : class Vector_clause_modifierContext;
262 : class Vector_no_modifier_clauseContext;
263 : class Vector_length_clauseContext;
264 : class Wait_clauseContext;
265 : class Wait_argument_clauseContext;
266 : class Wait_argumentContext;
267 : class Wait_int_expr_listContext;
268 : class Wait_int_exprContext;
269 : class Wait_argument_queuesContext;
270 : class Wait_argument_int_exprContext;
271 : class Worker_clauseContext;
272 : class Worker_clause_argsContext;
273 : class Worker_clause_modifierContext;
274 : class Worker_no_modifier_clauseContext;
275 : class Write_clauseContext;
276 : class Const_intContext;
277 : class Int_expr_listContext;
278 : class Int_exprContext;
279 : class Var_listContext;
280 : class VarContext;
281 :
282 : class AccContext : public antlr4::ParserRuleContext {
283 : public:
284 : AccContext(antlr4::ParserRuleContext *parent, size_t invokingState);
285 : virtual size_t getRuleIndex() const override;
286 : PrefixContext *prefix();
287 : antlr4::tree::TerminalNode *ACC();
288 : Openacc_directiveContext *openacc_directive();
289 : antlr4::tree::TerminalNode *EOF();
290 :
291 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
292 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
293 :
294 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
295 :
296 : };
297 :
298 : AccContext* acc();
299 :
300 : class PrefixContext : public antlr4::ParserRuleContext {
301 : public:
302 : PrefixContext(antlr4::ParserRuleContext *parent, size_t invokingState);
303 : virtual size_t getRuleIndex() const override;
304 : C_prefixContext *c_prefix();
305 : Fortran_prefixContext *fortran_prefix();
306 :
307 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
308 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
309 :
310 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
311 :
312 : };
313 :
314 : PrefixContext* prefix();
315 :
316 : class C_prefixContext : public antlr4::ParserRuleContext {
317 : public:
318 : C_prefixContext(antlr4::ParserRuleContext *parent, size_t invokingState);
319 : virtual size_t getRuleIndex() const override;
320 : antlr4::tree::TerminalNode *C_PREFIX();
321 :
322 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
323 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
324 :
325 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
326 :
327 : };
328 :
329 : C_prefixContext* c_prefix();
330 :
331 : class Fortran_prefixContext : public antlr4::ParserRuleContext {
332 : public:
333 : Fortran_prefixContext(antlr4::ParserRuleContext *parent, size_t invokingState);
334 : virtual size_t getRuleIndex() const override;
335 : antlr4::tree::TerminalNode *FORTRAN_PREFIX();
336 :
337 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
338 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
339 :
340 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
341 :
342 : };
343 :
344 : Fortran_prefixContext* fortran_prefix();
345 :
346 : class Openacc_directiveContext : public antlr4::ParserRuleContext {
347 : public:
348 : Openacc_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
349 : virtual size_t getRuleIndex() const override;
350 : Atomic_directiveContext *atomic_directive();
351 : Cache_directiveContext *cache_directive();
352 : Data_directiveContext *data_directive();
353 : Declare_directiveContext *declare_directive();
354 : End_directiveContext *end_directive();
355 : Enter_data_directiveContext *enter_data_directive();
356 : Exit_data_directiveContext *exit_data_directive();
357 : Host_data_directiveContext *host_data_directive();
358 : Init_directiveContext *init_directive();
359 : Kernels_directiveContext *kernels_directive();
360 : Kernels_loop_directiveContext *kernels_loop_directive();
361 : Loop_directiveContext *loop_directive();
362 : Parallel_directiveContext *parallel_directive();
363 : Parallel_loop_directiveContext *parallel_loop_directive();
364 : Routine_directiveContext *routine_directive();
365 : Serial_directiveContext *serial_directive();
366 : Serial_loop_directiveContext *serial_loop_directive();
367 : Set_directiveContext *set_directive();
368 : Shutdown_directiveContext *shutdown_directive();
369 : Update_directiveContext *update_directive();
370 : Wait_directiveContext *wait_directive();
371 :
372 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
373 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
374 :
375 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
376 :
377 : };
378 :
379 : Openacc_directiveContext* openacc_directive();
380 :
381 : class Atomic_directiveContext : public antlr4::ParserRuleContext {
382 : public:
383 : Atomic_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
384 : virtual size_t getRuleIndex() const override;
385 : antlr4::tree::TerminalNode *ATOMIC();
386 : Atomic_clauseContext *atomic_clause();
387 :
388 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
389 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
390 :
391 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
392 :
393 : };
394 :
395 : Atomic_directiveContext* atomic_directive();
396 :
397 : class Atomic_clauseContext : public antlr4::ParserRuleContext {
398 : public:
399 : Atomic_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
400 : virtual size_t getRuleIndex() const override;
401 : Capture_clauseContext *capture_clause();
402 : Read_clauseContext *read_clause();
403 : Update_clauseContext *update_clause();
404 : Write_clauseContext *write_clause();
405 :
406 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
407 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
408 :
409 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
410 :
411 : };
412 :
413 : Atomic_clauseContext* atomic_clause();
414 :
415 : class Cache_directiveContext : public antlr4::ParserRuleContext {
416 : public:
417 : Cache_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
418 : virtual size_t getRuleIndex() const override;
419 : antlr4::tree::TerminalNode *CACHE();
420 : antlr4::tree::TerminalNode *LEFT_PAREN();
421 : Var_listContext *var_list();
422 : antlr4::tree::TerminalNode *RIGHT_PAREN();
423 : Cache_directive_modifierContext *cache_directive_modifier();
424 : antlr4::tree::TerminalNode *COLON();
425 :
426 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
427 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
428 :
429 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
430 :
431 : };
432 :
433 : Cache_directiveContext* cache_directive();
434 :
435 : class Cache_directive_modifierContext : public antlr4::ParserRuleContext {
436 : public:
437 : Cache_directive_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
438 : virtual size_t getRuleIndex() const override;
439 : antlr4::tree::TerminalNode *READONLY();
440 :
441 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
442 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
443 :
444 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
445 :
446 : };
447 :
448 : Cache_directive_modifierContext* cache_directive_modifier();
449 :
450 : class Data_directiveContext : public antlr4::ParserRuleContext {
451 : public:
452 : Data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
453 : virtual size_t getRuleIndex() const override;
454 : antlr4::tree::TerminalNode *DATA();
455 : Data_clause_listContext *data_clause_list();
456 :
457 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
458 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
459 :
460 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
461 :
462 : };
463 :
464 : Data_directiveContext* data_directive();
465 :
466 : class Data_clause_listContext : public antlr4::ParserRuleContext {
467 : public:
468 : Data_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
469 : virtual size_t getRuleIndex() const override;
470 : std::vector<Data_clausesContext *> data_clauses();
471 : Data_clausesContext* data_clauses(size_t i);
472 :
473 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
474 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
475 :
476 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
477 :
478 : };
479 :
480 : Data_clause_listContext* data_clause_list();
481 :
482 : class Data_clausesContext : public antlr4::ParserRuleContext {
483 : public:
484 : Data_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
485 : virtual size_t getRuleIndex() const override;
486 : Attach_clauseContext *attach_clause();
487 : Copy_clauseContext *copy_clause();
488 : Copyin_clauseContext *copyin_clause();
489 : Copyout_clauseContext *copyout_clause();
490 : Create_clauseContext *create_clause();
491 : Default_clauseContext *default_clause();
492 : Deviceptr_clauseContext *deviceptr_clause();
493 : If_clauseContext *if_clause();
494 : No_create_clauseContext *no_create_clause();
495 : Present_clauseContext *present_clause();
496 :
497 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
498 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
499 :
500 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
501 :
502 : };
503 :
504 : Data_clausesContext* data_clauses();
505 :
506 : class Declare_directiveContext : public antlr4::ParserRuleContext {
507 : public:
508 : Declare_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
509 : virtual size_t getRuleIndex() const override;
510 : antlr4::tree::TerminalNode *DECLARE();
511 : Declare_clause_listContext *declare_clause_list();
512 :
513 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
514 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
515 :
516 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
517 :
518 : };
519 :
520 : Declare_directiveContext* declare_directive();
521 :
522 : class Declare_clause_listContext : public antlr4::ParserRuleContext {
523 : public:
524 : Declare_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
525 : virtual size_t getRuleIndex() const override;
526 : std::vector<Declare_clausesContext *> declare_clauses();
527 : Declare_clausesContext* declare_clauses(size_t i);
528 :
529 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
530 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
531 :
532 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
533 :
534 : };
535 :
536 : Declare_clause_listContext* declare_clause_list();
537 :
538 : class Declare_clausesContext : public antlr4::ParserRuleContext {
539 : public:
540 : Declare_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
541 : virtual size_t getRuleIndex() const override;
542 : Copy_clauseContext *copy_clause();
543 : Copyin_clauseContext *copyin_clause();
544 : Copyout_no_modifier_clauseContext *copyout_no_modifier_clause();
545 : Create_no_modifier_clauseContext *create_no_modifier_clause();
546 : Device_resident_clauseContext *device_resident_clause();
547 : Deviceptr_clauseContext *deviceptr_clause();
548 : Link_clauseContext *link_clause();
549 : Present_clauseContext *present_clause();
550 :
551 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
552 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
553 :
554 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
555 :
556 : };
557 :
558 : Declare_clausesContext* declare_clauses();
559 :
560 : class End_directiveContext : public antlr4::ParserRuleContext {
561 : public:
562 : End_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
563 : virtual size_t getRuleIndex() const override;
564 : antlr4::tree::TerminalNode *END();
565 : End_clause_seqContext *end_clause_seq();
566 :
567 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
568 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
569 :
570 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
571 :
572 : };
573 :
574 : End_directiveContext* end_directive();
575 :
576 : class End_clause_seqContext : public antlr4::ParserRuleContext {
577 : public:
578 : End_clause_seqContext(antlr4::ParserRuleContext *parent, size_t invokingState);
579 : virtual size_t getRuleIndex() const override;
580 : Fortran_paired_directiveContext *fortran_paired_directive();
581 :
582 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
583 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
584 :
585 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
586 :
587 : };
588 :
589 : End_clause_seqContext* end_clause_seq();
590 :
591 : class Fortran_paired_directiveContext : public antlr4::ParserRuleContext {
592 : public:
593 : Fortran_paired_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
594 : virtual size_t getRuleIndex() const override;
595 : End_atomic_directiveContext *end_atomic_directive();
596 : End_data_directiveContext *end_data_directive();
597 : End_host_data_directiveContext *end_host_data_directive();
598 : End_kernels_directiveContext *end_kernels_directive();
599 : End_kernels_loop_directiveContext *end_kernels_loop_directive();
600 : End_parallel_directiveContext *end_parallel_directive();
601 : End_parallel_loop_directiveContext *end_parallel_loop_directive();
602 : End_serial_directiveContext *end_serial_directive();
603 : End_serial_loop_directiveContext *end_serial_loop_directive();
604 :
605 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
606 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
607 :
608 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
609 :
610 : };
611 :
612 : Fortran_paired_directiveContext* fortran_paired_directive();
613 :
614 : class End_atomic_directiveContext : public antlr4::ParserRuleContext {
615 : public:
616 : End_atomic_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
617 : virtual size_t getRuleIndex() const override;
618 : Atomic_directiveContext *atomic_directive();
619 :
620 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
621 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
622 :
623 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
624 :
625 : };
626 :
627 : End_atomic_directiveContext* end_atomic_directive();
628 :
629 : class End_data_directiveContext : public antlr4::ParserRuleContext {
630 : public:
631 : End_data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
632 : virtual size_t getRuleIndex() const override;
633 : Data_directiveContext *data_directive();
634 :
635 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
636 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
637 :
638 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
639 :
640 : };
641 :
642 : End_data_directiveContext* end_data_directive();
643 :
644 : class End_host_data_directiveContext : public antlr4::ParserRuleContext {
645 : public:
646 : End_host_data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
647 : virtual size_t getRuleIndex() const override;
648 : antlr4::tree::TerminalNode *HOST_DATA();
649 :
650 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
651 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
652 :
653 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
654 :
655 : };
656 :
657 : End_host_data_directiveContext* end_host_data_directive();
658 :
659 : class End_kernels_directiveContext : public antlr4::ParserRuleContext {
660 : public:
661 : End_kernels_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
662 : virtual size_t getRuleIndex() const override;
663 : Kernels_directiveContext *kernels_directive();
664 :
665 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
666 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
667 :
668 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
669 :
670 : };
671 :
672 : End_kernels_directiveContext* end_kernels_directive();
673 :
674 : class End_kernels_loop_directiveContext : public antlr4::ParserRuleContext {
675 : public:
676 : End_kernels_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
677 : virtual size_t getRuleIndex() const override;
678 : Kernels_loop_directiveContext *kernels_loop_directive();
679 :
680 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
681 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
682 :
683 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
684 :
685 : };
686 :
687 : End_kernels_loop_directiveContext* end_kernels_loop_directive();
688 :
689 : class End_parallel_directiveContext : public antlr4::ParserRuleContext {
690 : public:
691 : End_parallel_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
692 : virtual size_t getRuleIndex() const override;
693 : Parallel_directiveContext *parallel_directive();
694 :
695 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
696 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
697 :
698 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
699 :
700 : };
701 :
702 : End_parallel_directiveContext* end_parallel_directive();
703 :
704 : class End_parallel_loop_directiveContext : public antlr4::ParserRuleContext {
705 : public:
706 : End_parallel_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
707 : virtual size_t getRuleIndex() const override;
708 : Parallel_loop_directiveContext *parallel_loop_directive();
709 :
710 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
711 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
712 :
713 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
714 :
715 : };
716 :
717 : End_parallel_loop_directiveContext* end_parallel_loop_directive();
718 :
719 : class End_serial_directiveContext : public antlr4::ParserRuleContext {
720 : public:
721 : End_serial_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
722 : virtual size_t getRuleIndex() const override;
723 : Serial_directiveContext *serial_directive();
724 :
725 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
726 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
727 :
728 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
729 :
730 : };
731 :
732 : End_serial_directiveContext* end_serial_directive();
733 :
734 : class End_serial_loop_directiveContext : public antlr4::ParserRuleContext {
735 : public:
736 : End_serial_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
737 : virtual size_t getRuleIndex() const override;
738 : Serial_loop_directiveContext *serial_loop_directive();
739 :
740 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
741 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
742 :
743 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
744 :
745 : };
746 :
747 : End_serial_loop_directiveContext* end_serial_loop_directive();
748 :
749 : class Enter_data_directiveContext : public antlr4::ParserRuleContext {
750 : public:
751 : Enter_data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
752 : virtual size_t getRuleIndex() const override;
753 : antlr4::tree::TerminalNode *ENTER();
754 : antlr4::tree::TerminalNode *DATA();
755 : Enter_data_clause_listContext *enter_data_clause_list();
756 :
757 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
758 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
759 :
760 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
761 :
762 : };
763 :
764 : Enter_data_directiveContext* enter_data_directive();
765 :
766 : class Enter_data_clause_listContext : public antlr4::ParserRuleContext {
767 : public:
768 : Enter_data_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
769 : virtual size_t getRuleIndex() const override;
770 : std::vector<Enter_data_clausesContext *> enter_data_clauses();
771 : Enter_data_clausesContext* enter_data_clauses(size_t i);
772 :
773 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
774 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
775 :
776 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
777 :
778 : };
779 :
780 : Enter_data_clause_listContext* enter_data_clause_list();
781 :
782 : class Enter_data_clausesContext : public antlr4::ParserRuleContext {
783 : public:
784 : Enter_data_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
785 : virtual size_t getRuleIndex() const override;
786 : Async_clauseContext *async_clause();
787 : Attach_clauseContext *attach_clause();
788 : Copyin_no_modifier_clauseContext *copyin_no_modifier_clause();
789 : Create_clauseContext *create_clause();
790 : If_clauseContext *if_clause();
791 : Wait_argument_clauseContext *wait_argument_clause();
792 :
793 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
794 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
795 :
796 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
797 :
798 : };
799 :
800 : Enter_data_clausesContext* enter_data_clauses();
801 :
802 : class Exit_data_directiveContext : public antlr4::ParserRuleContext {
803 : public:
804 : Exit_data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
805 : virtual size_t getRuleIndex() const override;
806 : antlr4::tree::TerminalNode *EXIT();
807 : antlr4::tree::TerminalNode *DATA();
808 : Exit_data_clause_listContext *exit_data_clause_list();
809 :
810 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
811 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
812 :
813 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
814 :
815 : };
816 :
817 : Exit_data_directiveContext* exit_data_directive();
818 :
819 : class Exit_data_clause_listContext : public antlr4::ParserRuleContext {
820 : public:
821 : Exit_data_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
822 : virtual size_t getRuleIndex() const override;
823 : std::vector<Exit_data_clausesContext *> exit_data_clauses();
824 : Exit_data_clausesContext* exit_data_clauses(size_t i);
825 :
826 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
827 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
828 :
829 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
830 :
831 : };
832 :
833 : Exit_data_clause_listContext* exit_data_clause_list();
834 :
835 : class Exit_data_clausesContext : public antlr4::ParserRuleContext {
836 : public:
837 : Exit_data_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
838 : virtual size_t getRuleIndex() const override;
839 : Async_clauseContext *async_clause();
840 : Copyout_no_modifier_clauseContext *copyout_no_modifier_clause();
841 : Delete_clauseContext *delete_clause();
842 : Detach_clauseContext *detach_clause();
843 : Finalize_clauseContext *finalize_clause();
844 : If_clauseContext *if_clause();
845 : Wait_argument_clauseContext *wait_argument_clause();
846 :
847 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
848 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
849 :
850 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
851 :
852 : };
853 :
854 : Exit_data_clausesContext* exit_data_clauses();
855 :
856 : class Host_data_directiveContext : public antlr4::ParserRuleContext {
857 : public:
858 : Host_data_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
859 : virtual size_t getRuleIndex() const override;
860 : antlr4::tree::TerminalNode *HOST_DATA();
861 : Host_data_clause_listContext *host_data_clause_list();
862 :
863 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
864 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
865 :
866 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
867 :
868 : };
869 :
870 : Host_data_directiveContext* host_data_directive();
871 :
872 : class Host_data_clause_listContext : public antlr4::ParserRuleContext {
873 : public:
874 : Host_data_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
875 : virtual size_t getRuleIndex() const override;
876 : std::vector<Host_data_clausesContext *> host_data_clauses();
877 : Host_data_clausesContext* host_data_clauses(size_t i);
878 :
879 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
880 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
881 :
882 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
883 :
884 : };
885 :
886 : Host_data_clause_listContext* host_data_clause_list();
887 :
888 : class Host_data_clausesContext : public antlr4::ParserRuleContext {
889 : public:
890 : Host_data_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
891 : virtual size_t getRuleIndex() const override;
892 : If_clauseContext *if_clause();
893 : If_present_clauseContext *if_present_clause();
894 : Use_device_clauseContext *use_device_clause();
895 :
896 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
897 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
898 :
899 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
900 :
901 : };
902 :
903 : Host_data_clausesContext* host_data_clauses();
904 :
905 : class Init_directiveContext : public antlr4::ParserRuleContext {
906 : public:
907 : Init_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
908 : virtual size_t getRuleIndex() const override;
909 : antlr4::tree::TerminalNode *INIT();
910 : Init_clause_listContext *init_clause_list();
911 :
912 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
913 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
914 :
915 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
916 :
917 : };
918 :
919 : Init_directiveContext* init_directive();
920 :
921 : class Init_clause_listContext : public antlr4::ParserRuleContext {
922 : public:
923 : Init_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
924 : virtual size_t getRuleIndex() const override;
925 : std::vector<Init_clausesContext *> init_clauses();
926 : Init_clausesContext* init_clauses(size_t i);
927 :
928 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
929 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
930 :
931 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
932 :
933 : };
934 :
935 : Init_clause_listContext* init_clause_list();
936 :
937 : class Init_clausesContext : public antlr4::ParserRuleContext {
938 : public:
939 : Init_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
940 : virtual size_t getRuleIndex() const override;
941 : Device_type_clauseContext *device_type_clause();
942 : Device_num_clauseContext *device_num_clause();
943 : If_clauseContext *if_clause();
944 :
945 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
946 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
947 :
948 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
949 :
950 : };
951 :
952 : Init_clausesContext* init_clauses();
953 :
954 : class Kernels_directiveContext : public antlr4::ParserRuleContext {
955 : public:
956 : Kernels_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
957 : virtual size_t getRuleIndex() const override;
958 : antlr4::tree::TerminalNode *KERNELS();
959 : Kernels_clause_listContext *kernels_clause_list();
960 :
961 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
962 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
963 :
964 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
965 :
966 : };
967 :
968 : Kernels_directiveContext* kernels_directive();
969 :
970 : class Kernels_clause_listContext : public antlr4::ParserRuleContext {
971 : public:
972 : Kernels_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
973 : virtual size_t getRuleIndex() const override;
974 : std::vector<Kernels_clausesContext *> kernels_clauses();
975 : Kernels_clausesContext* kernels_clauses(size_t i);
976 :
977 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
978 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
979 :
980 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
981 :
982 : };
983 :
984 : Kernels_clause_listContext* kernels_clause_list();
985 :
986 : class Kernels_clausesContext : public antlr4::ParserRuleContext {
987 : public:
988 : Kernels_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
989 : virtual size_t getRuleIndex() const override;
990 : Async_clauseContext *async_clause();
991 : Attach_clauseContext *attach_clause();
992 : Copy_clauseContext *copy_clause();
993 : Copyin_clauseContext *copyin_clause();
994 : Copyout_clauseContext *copyout_clause();
995 : Create_clauseContext *create_clause();
996 : Default_clauseContext *default_clause();
997 : Device_type_clauseContext *device_type_clause();
998 : Deviceptr_clauseContext *deviceptr_clause();
999 : If_clauseContext *if_clause();
1000 : No_create_clauseContext *no_create_clause();
1001 : Num_gangs_clauseContext *num_gangs_clause();
1002 : Num_workers_clauseContext *num_workers_clause();
1003 : Present_clauseContext *present_clause();
1004 : Self_clauseContext *self_clause();
1005 : Vector_length_clauseContext *vector_length_clause();
1006 : Wait_clauseContext *wait_clause();
1007 :
1008 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1009 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1010 :
1011 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1012 :
1013 : };
1014 :
1015 : Kernels_clausesContext* kernels_clauses();
1016 :
1017 : class Kernels_loop_directiveContext : public antlr4::ParserRuleContext {
1018 : public:
1019 : Kernels_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1020 : virtual size_t getRuleIndex() const override;
1021 : antlr4::tree::TerminalNode *KERNELS();
1022 : antlr4::tree::TerminalNode *LOOP();
1023 : Kernels_loop_clause_listContext *kernels_loop_clause_list();
1024 :
1025 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1026 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1027 :
1028 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1029 :
1030 : };
1031 :
1032 : Kernels_loop_directiveContext* kernels_loop_directive();
1033 :
1034 : class Kernels_loop_clause_listContext : public antlr4::ParserRuleContext {
1035 : public:
1036 : Kernels_loop_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1037 : virtual size_t getRuleIndex() const override;
1038 : std::vector<Kernels_loop_clausesContext *> kernels_loop_clauses();
1039 : Kernels_loop_clausesContext* kernels_loop_clauses(size_t i);
1040 :
1041 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1042 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1043 :
1044 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1045 :
1046 : };
1047 :
1048 : Kernels_loop_clause_listContext* kernels_loop_clause_list();
1049 :
1050 : class Kernels_loop_clausesContext : public antlr4::ParserRuleContext {
1051 : public:
1052 : Kernels_loop_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1053 : virtual size_t getRuleIndex() const override;
1054 : Async_clauseContext *async_clause();
1055 : Attach_clauseContext *attach_clause();
1056 : Auto_clauseContext *auto_clause();
1057 : Collapse_clauseContext *collapse_clause();
1058 : Copy_clauseContext *copy_clause();
1059 : Copyin_clauseContext *copyin_clause();
1060 : Copyout_clauseContext *copyout_clause();
1061 : Create_clauseContext *create_clause();
1062 : Default_clauseContext *default_clause();
1063 : Device_type_clauseContext *device_type_clause();
1064 : Deviceptr_clauseContext *deviceptr_clause();
1065 : Gang_clauseContext *gang_clause();
1066 : If_clauseContext *if_clause();
1067 : Independent_clauseContext *independent_clause();
1068 : No_create_clauseContext *no_create_clause();
1069 : Num_gangs_clauseContext *num_gangs_clause();
1070 : Num_workers_clauseContext *num_workers_clause();
1071 : Present_clauseContext *present_clause();
1072 : Private_clauseContext *private_clause();
1073 : Reduction_clauseContext *reduction_clause();
1074 : Self_clauseContext *self_clause();
1075 : Seq_clauseContext *seq_clause();
1076 : Tile_clauseContext *tile_clause();
1077 : Vector_clauseContext *vector_clause();
1078 : Vector_length_clauseContext *vector_length_clause();
1079 : Wait_clauseContext *wait_clause();
1080 : Worker_clauseContext *worker_clause();
1081 :
1082 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1083 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1084 :
1085 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1086 :
1087 : };
1088 :
1089 : Kernels_loop_clausesContext* kernels_loop_clauses();
1090 :
1091 : class Loop_directiveContext : public antlr4::ParserRuleContext {
1092 : public:
1093 : Loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1094 : virtual size_t getRuleIndex() const override;
1095 : antlr4::tree::TerminalNode *LOOP();
1096 : Loop_clause_listContext *loop_clause_list();
1097 :
1098 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1099 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1100 :
1101 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1102 :
1103 : };
1104 :
1105 : Loop_directiveContext* loop_directive();
1106 :
1107 : class Loop_clause_listContext : public antlr4::ParserRuleContext {
1108 : public:
1109 : Loop_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1110 : virtual size_t getRuleIndex() const override;
1111 : std::vector<Loop_clausesContext *> loop_clauses();
1112 : Loop_clausesContext* loop_clauses(size_t i);
1113 :
1114 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1115 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1116 :
1117 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1118 :
1119 : };
1120 :
1121 : Loop_clause_listContext* loop_clause_list();
1122 :
1123 : class Loop_clausesContext : public antlr4::ParserRuleContext {
1124 : public:
1125 : Loop_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1126 : virtual size_t getRuleIndex() const override;
1127 : Auto_clauseContext *auto_clause();
1128 : Collapse_clauseContext *collapse_clause();
1129 : Device_type_clauseContext *device_type_clause();
1130 : Gang_clauseContext *gang_clause();
1131 : Independent_clauseContext *independent_clause();
1132 : Private_clauseContext *private_clause();
1133 : Reduction_clauseContext *reduction_clause();
1134 : Seq_clauseContext *seq_clause();
1135 : Tile_clauseContext *tile_clause();
1136 : Vector_clauseContext *vector_clause();
1137 : Worker_clauseContext *worker_clause();
1138 :
1139 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1140 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1141 :
1142 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1143 :
1144 : };
1145 :
1146 : Loop_clausesContext* loop_clauses();
1147 :
1148 : class Parallel_directiveContext : public antlr4::ParserRuleContext {
1149 : public:
1150 : Parallel_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1151 : virtual size_t getRuleIndex() const override;
1152 : antlr4::tree::TerminalNode *PARALLEL();
1153 : Parallel_clause_listContext *parallel_clause_list();
1154 :
1155 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1156 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1157 :
1158 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1159 :
1160 : };
1161 :
1162 : Parallel_directiveContext* parallel_directive();
1163 :
1164 : class Parallel_clause_listContext : public antlr4::ParserRuleContext {
1165 : public:
1166 : Parallel_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1167 : virtual size_t getRuleIndex() const override;
1168 : std::vector<Parallel_clausesContext *> parallel_clauses();
1169 : Parallel_clausesContext* parallel_clauses(size_t i);
1170 :
1171 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1172 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1173 :
1174 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1175 :
1176 : };
1177 :
1178 : Parallel_clause_listContext* parallel_clause_list();
1179 :
1180 : class Parallel_clausesContext : public antlr4::ParserRuleContext {
1181 : public:
1182 : Parallel_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1183 : virtual size_t getRuleIndex() const override;
1184 : Async_clauseContext *async_clause();
1185 : Attach_clauseContext *attach_clause();
1186 : Copy_clauseContext *copy_clause();
1187 : Copyin_clauseContext *copyin_clause();
1188 : Copyout_clauseContext *copyout_clause();
1189 : Create_clauseContext *create_clause();
1190 : Default_clauseContext *default_clause();
1191 : Device_type_clauseContext *device_type_clause();
1192 : Deviceptr_clauseContext *deviceptr_clause();
1193 : Firstprivate_clauseContext *firstprivate_clause();
1194 : If_clauseContext *if_clause();
1195 : No_create_clauseContext *no_create_clause();
1196 : Num_gangs_clauseContext *num_gangs_clause();
1197 : Num_workers_clauseContext *num_workers_clause();
1198 : Present_clauseContext *present_clause();
1199 : Private_clauseContext *private_clause();
1200 : Reduction_clauseContext *reduction_clause();
1201 : Self_clauseContext *self_clause();
1202 : Vector_length_clauseContext *vector_length_clause();
1203 : Wait_clauseContext *wait_clause();
1204 :
1205 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1206 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1207 :
1208 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1209 :
1210 : };
1211 :
1212 : Parallel_clausesContext* parallel_clauses();
1213 :
1214 : class Parallel_loop_directiveContext : public antlr4::ParserRuleContext {
1215 : public:
1216 : Parallel_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1217 : virtual size_t getRuleIndex() const override;
1218 : antlr4::tree::TerminalNode *PARALLEL();
1219 : antlr4::tree::TerminalNode *LOOP();
1220 : Parallel_loop_clause_listContext *parallel_loop_clause_list();
1221 :
1222 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1223 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1224 :
1225 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1226 :
1227 : };
1228 :
1229 : Parallel_loop_directiveContext* parallel_loop_directive();
1230 :
1231 : class Parallel_loop_clause_listContext : public antlr4::ParserRuleContext {
1232 : public:
1233 : Parallel_loop_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1234 : virtual size_t getRuleIndex() const override;
1235 : std::vector<Parallel_loop_clausesContext *> parallel_loop_clauses();
1236 : Parallel_loop_clausesContext* parallel_loop_clauses(size_t i);
1237 :
1238 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1239 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1240 :
1241 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1242 :
1243 : };
1244 :
1245 : Parallel_loop_clause_listContext* parallel_loop_clause_list();
1246 :
1247 : class Parallel_loop_clausesContext : public antlr4::ParserRuleContext {
1248 : public:
1249 : Parallel_loop_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1250 : virtual size_t getRuleIndex() const override;
1251 : Async_clauseContext *async_clause();
1252 : Attach_clauseContext *attach_clause();
1253 : Auto_clauseContext *auto_clause();
1254 : Collapse_clauseContext *collapse_clause();
1255 : Copy_clauseContext *copy_clause();
1256 : Copyin_clauseContext *copyin_clause();
1257 : Copyout_clauseContext *copyout_clause();
1258 : Create_clauseContext *create_clause();
1259 : Default_clauseContext *default_clause();
1260 : Device_type_clauseContext *device_type_clause();
1261 : Deviceptr_clauseContext *deviceptr_clause();
1262 : Firstprivate_clauseContext *firstprivate_clause();
1263 : Gang_clauseContext *gang_clause();
1264 : If_clauseContext *if_clause();
1265 : Independent_clauseContext *independent_clause();
1266 : No_create_clauseContext *no_create_clause();
1267 : Num_gangs_clauseContext *num_gangs_clause();
1268 : Num_workers_clauseContext *num_workers_clause();
1269 : Present_clauseContext *present_clause();
1270 : Private_clauseContext *private_clause();
1271 : Reduction_clauseContext *reduction_clause();
1272 : Self_clauseContext *self_clause();
1273 : Seq_clauseContext *seq_clause();
1274 : Tile_clauseContext *tile_clause();
1275 : Vector_clauseContext *vector_clause();
1276 : Vector_length_clauseContext *vector_length_clause();
1277 : Wait_clauseContext *wait_clause();
1278 : Worker_clauseContext *worker_clause();
1279 :
1280 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1281 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1282 :
1283 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1284 :
1285 : };
1286 :
1287 : Parallel_loop_clausesContext* parallel_loop_clauses();
1288 :
1289 : class Routine_directiveContext : public antlr4::ParserRuleContext {
1290 : public:
1291 : Routine_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1292 : virtual size_t getRuleIndex() const override;
1293 : antlr4::tree::TerminalNode *ROUTINE();
1294 : Routine_clause_listContext *routine_clause_list();
1295 : antlr4::tree::TerminalNode *LEFT_PAREN();
1296 : NameContext *name();
1297 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1298 :
1299 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1300 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1301 :
1302 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1303 :
1304 : };
1305 :
1306 : Routine_directiveContext* routine_directive();
1307 :
1308 : class Routine_clause_listContext : public antlr4::ParserRuleContext {
1309 : public:
1310 : Routine_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1311 : virtual size_t getRuleIndex() const override;
1312 : std::vector<Routine_clausesContext *> routine_clauses();
1313 : Routine_clausesContext* routine_clauses(size_t i);
1314 :
1315 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1316 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1317 :
1318 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1319 :
1320 : };
1321 :
1322 : Routine_clause_listContext* routine_clause_list();
1323 :
1324 : class Routine_clausesContext : public antlr4::ParserRuleContext {
1325 : public:
1326 : Routine_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1327 : virtual size_t getRuleIndex() const override;
1328 : Bind_clauseContext *bind_clause();
1329 : Device_type_clauseContext *device_type_clause();
1330 : Gang_no_list_clauseContext *gang_no_list_clause();
1331 : Nohost_clauseContext *nohost_clause();
1332 : Seq_clauseContext *seq_clause();
1333 : Vector_no_modifier_clauseContext *vector_no_modifier_clause();
1334 : Worker_no_modifier_clauseContext *worker_no_modifier_clause();
1335 :
1336 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1337 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1338 :
1339 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1340 :
1341 : };
1342 :
1343 : Routine_clausesContext* routine_clauses();
1344 :
1345 : class NameContext : public antlr4::ParserRuleContext {
1346 : public:
1347 : NameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1348 : virtual size_t getRuleIndex() const override;
1349 : antlr4::tree::TerminalNode *EXPR();
1350 :
1351 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1352 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1353 :
1354 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1355 :
1356 : };
1357 :
1358 : NameContext* name();
1359 :
1360 : class Serial_directiveContext : public antlr4::ParserRuleContext {
1361 : public:
1362 : Serial_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1363 : virtual size_t getRuleIndex() const override;
1364 : antlr4::tree::TerminalNode *SERIAL();
1365 : Serial_clause_listContext *serial_clause_list();
1366 :
1367 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1368 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1369 :
1370 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1371 :
1372 : };
1373 :
1374 : Serial_directiveContext* serial_directive();
1375 :
1376 : class Serial_clause_listContext : public antlr4::ParserRuleContext {
1377 : public:
1378 : Serial_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1379 : virtual size_t getRuleIndex() const override;
1380 : std::vector<Serial_clausesContext *> serial_clauses();
1381 : Serial_clausesContext* serial_clauses(size_t i);
1382 :
1383 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1384 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1385 :
1386 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1387 :
1388 : };
1389 :
1390 : Serial_clause_listContext* serial_clause_list();
1391 :
1392 : class Serial_clausesContext : public antlr4::ParserRuleContext {
1393 : public:
1394 : Serial_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1395 : virtual size_t getRuleIndex() const override;
1396 : Async_clauseContext *async_clause();
1397 : Attach_clauseContext *attach_clause();
1398 : Copy_clauseContext *copy_clause();
1399 : Copyin_clauseContext *copyin_clause();
1400 : Copyout_clauseContext *copyout_clause();
1401 : Create_clauseContext *create_clause();
1402 : Default_clauseContext *default_clause();
1403 : Device_type_clauseContext *device_type_clause();
1404 : Deviceptr_clauseContext *deviceptr_clause();
1405 : Firstprivate_clauseContext *firstprivate_clause();
1406 : If_clauseContext *if_clause();
1407 : No_create_clauseContext *no_create_clause();
1408 : Present_clauseContext *present_clause();
1409 : Private_clauseContext *private_clause();
1410 : Reduction_clauseContext *reduction_clause();
1411 : Self_clauseContext *self_clause();
1412 : Wait_clauseContext *wait_clause();
1413 :
1414 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1415 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1416 :
1417 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1418 :
1419 : };
1420 :
1421 : Serial_clausesContext* serial_clauses();
1422 :
1423 : class Serial_loop_directiveContext : public antlr4::ParserRuleContext {
1424 : public:
1425 : Serial_loop_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1426 : virtual size_t getRuleIndex() const override;
1427 : antlr4::tree::TerminalNode *SERIAL();
1428 : antlr4::tree::TerminalNode *LOOP();
1429 : Serial_loop_clause_listContext *serial_loop_clause_list();
1430 :
1431 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1432 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1433 :
1434 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1435 :
1436 : };
1437 :
1438 : Serial_loop_directiveContext* serial_loop_directive();
1439 :
1440 : class Serial_loop_clause_listContext : public antlr4::ParserRuleContext {
1441 : public:
1442 : Serial_loop_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1443 : virtual size_t getRuleIndex() const override;
1444 : std::vector<Serial_loop_clausesContext *> serial_loop_clauses();
1445 : Serial_loop_clausesContext* serial_loop_clauses(size_t i);
1446 :
1447 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1448 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1449 :
1450 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1451 :
1452 : };
1453 :
1454 : Serial_loop_clause_listContext* serial_loop_clause_list();
1455 :
1456 : class Serial_loop_clausesContext : public antlr4::ParserRuleContext {
1457 : public:
1458 : Serial_loop_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1459 : virtual size_t getRuleIndex() const override;
1460 : Async_clauseContext *async_clause();
1461 : Attach_clauseContext *attach_clause();
1462 : Auto_clauseContext *auto_clause();
1463 : Collapse_clauseContext *collapse_clause();
1464 : Copy_clauseContext *copy_clause();
1465 : Copyin_clauseContext *copyin_clause();
1466 : Copyout_clauseContext *copyout_clause();
1467 : Create_clauseContext *create_clause();
1468 : Default_clauseContext *default_clause();
1469 : Device_type_clauseContext *device_type_clause();
1470 : Deviceptr_clauseContext *deviceptr_clause();
1471 : Firstprivate_clauseContext *firstprivate_clause();
1472 : Gang_clauseContext *gang_clause();
1473 : If_clauseContext *if_clause();
1474 : Independent_clauseContext *independent_clause();
1475 : No_create_clauseContext *no_create_clause();
1476 : Present_clauseContext *present_clause();
1477 : Private_clauseContext *private_clause();
1478 : Reduction_clauseContext *reduction_clause();
1479 : Self_clauseContext *self_clause();
1480 : Seq_clauseContext *seq_clause();
1481 : Tile_clauseContext *tile_clause();
1482 : Vector_clauseContext *vector_clause();
1483 : Wait_clauseContext *wait_clause();
1484 : Worker_clauseContext *worker_clause();
1485 :
1486 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1487 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1488 :
1489 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1490 :
1491 : };
1492 :
1493 : Serial_loop_clausesContext* serial_loop_clauses();
1494 :
1495 : class Set_directiveContext : public antlr4::ParserRuleContext {
1496 : public:
1497 : Set_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1498 : virtual size_t getRuleIndex() const override;
1499 : antlr4::tree::TerminalNode *SET();
1500 : Set_clause_listContext *set_clause_list();
1501 :
1502 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1503 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1504 :
1505 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1506 :
1507 : };
1508 :
1509 : Set_directiveContext* set_directive();
1510 :
1511 : class Set_clause_listContext : public antlr4::ParserRuleContext {
1512 : public:
1513 : Set_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1514 : virtual size_t getRuleIndex() const override;
1515 : std::vector<Set_clausesContext *> set_clauses();
1516 : Set_clausesContext* set_clauses(size_t i);
1517 :
1518 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1519 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1520 :
1521 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1522 :
1523 : };
1524 :
1525 : Set_clause_listContext* set_clause_list();
1526 :
1527 : class Set_clausesContext : public antlr4::ParserRuleContext {
1528 : public:
1529 : Set_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1530 : virtual size_t getRuleIndex() const override;
1531 : Default_async_clauseContext *default_async_clause();
1532 : Device_type_clauseContext *device_type_clause();
1533 : Device_num_clauseContext *device_num_clause();
1534 : If_clauseContext *if_clause();
1535 :
1536 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1537 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1538 :
1539 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1540 :
1541 : };
1542 :
1543 : Set_clausesContext* set_clauses();
1544 :
1545 : class Shutdown_directiveContext : public antlr4::ParserRuleContext {
1546 : public:
1547 : Shutdown_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1548 : virtual size_t getRuleIndex() const override;
1549 : antlr4::tree::TerminalNode *SHUTDOWN();
1550 : Shutdown_clause_listContext *shutdown_clause_list();
1551 :
1552 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1553 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1554 :
1555 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1556 :
1557 : };
1558 :
1559 : Shutdown_directiveContext* shutdown_directive();
1560 :
1561 : class Shutdown_clause_listContext : public antlr4::ParserRuleContext {
1562 : public:
1563 : Shutdown_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1564 : virtual size_t getRuleIndex() const override;
1565 : std::vector<Shutdown_clausesContext *> shutdown_clauses();
1566 : Shutdown_clausesContext* shutdown_clauses(size_t i);
1567 :
1568 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1569 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1570 :
1571 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1572 :
1573 : };
1574 :
1575 : Shutdown_clause_listContext* shutdown_clause_list();
1576 :
1577 : class Shutdown_clausesContext : public antlr4::ParserRuleContext {
1578 : public:
1579 : Shutdown_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1580 : virtual size_t getRuleIndex() const override;
1581 : Device_type_clauseContext *device_type_clause();
1582 : Device_num_clauseContext *device_num_clause();
1583 : If_clauseContext *if_clause();
1584 :
1585 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1586 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1587 :
1588 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1589 :
1590 : };
1591 :
1592 : Shutdown_clausesContext* shutdown_clauses();
1593 :
1594 : class Update_directiveContext : public antlr4::ParserRuleContext {
1595 : public:
1596 : Update_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1597 : virtual size_t getRuleIndex() const override;
1598 : antlr4::tree::TerminalNode *UPDATE();
1599 : Update_clause_listContext *update_clause_list();
1600 :
1601 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1602 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1603 :
1604 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1605 :
1606 : };
1607 :
1608 : Update_directiveContext* update_directive();
1609 :
1610 : class Update_clause_listContext : public antlr4::ParserRuleContext {
1611 : public:
1612 : Update_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1613 : virtual size_t getRuleIndex() const override;
1614 : std::vector<Update_clausesContext *> update_clauses();
1615 : Update_clausesContext* update_clauses(size_t i);
1616 :
1617 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1618 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1619 :
1620 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1621 :
1622 : };
1623 :
1624 : Update_clause_listContext* update_clause_list();
1625 :
1626 : class Update_clausesContext : public antlr4::ParserRuleContext {
1627 : public:
1628 : Update_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1629 : virtual size_t getRuleIndex() const override;
1630 : Async_clauseContext *async_clause();
1631 : Device_clauseContext *device_clause();
1632 : Device_type_clauseContext *device_type_clause();
1633 : Host_clauseContext *host_clause();
1634 : If_clauseContext *if_clause();
1635 : If_present_clauseContext *if_present_clause();
1636 : Self_list_clauseContext *self_list_clause();
1637 : Wait_argument_clauseContext *wait_argument_clause();
1638 :
1639 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1640 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1641 :
1642 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1643 :
1644 : };
1645 :
1646 : Update_clausesContext* update_clauses();
1647 :
1648 : class Wait_directiveContext : public antlr4::ParserRuleContext {
1649 : public:
1650 : Wait_directiveContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1651 : virtual size_t getRuleIndex() const override;
1652 : antlr4::tree::TerminalNode *WAIT();
1653 : Wait_clause_listContext *wait_clause_list();
1654 : antlr4::tree::TerminalNode *LEFT_PAREN();
1655 : Wait_argumentContext *wait_argument();
1656 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1657 :
1658 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1659 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1660 :
1661 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1662 :
1663 : };
1664 :
1665 : Wait_directiveContext* wait_directive();
1666 :
1667 : class Wait_clause_listContext : public antlr4::ParserRuleContext {
1668 : public:
1669 : Wait_clause_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1670 : virtual size_t getRuleIndex() const override;
1671 : std::vector<Wait_clausesContext *> wait_clauses();
1672 : Wait_clausesContext* wait_clauses(size_t i);
1673 :
1674 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1675 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1676 :
1677 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1678 :
1679 : };
1680 :
1681 : Wait_clause_listContext* wait_clause_list();
1682 :
1683 : class Wait_clausesContext : public antlr4::ParserRuleContext {
1684 : public:
1685 : Wait_clausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1686 : virtual size_t getRuleIndex() const override;
1687 : Async_clauseContext *async_clause();
1688 : If_clauseContext *if_clause();
1689 :
1690 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1691 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1692 :
1693 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1694 :
1695 : };
1696 :
1697 : Wait_clausesContext* wait_clauses();
1698 :
1699 : class Async_clauseContext : public antlr4::ParserRuleContext {
1700 : public:
1701 : Async_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1702 : virtual size_t getRuleIndex() const override;
1703 : antlr4::tree::TerminalNode *ASYNC();
1704 : antlr4::tree::TerminalNode *LEFT_PAREN();
1705 : Int_exprContext *int_expr();
1706 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1707 :
1708 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1709 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1710 :
1711 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1712 :
1713 : };
1714 :
1715 : Async_clauseContext* async_clause();
1716 :
1717 : class Attach_clauseContext : public antlr4::ParserRuleContext {
1718 : public:
1719 : Attach_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1720 : virtual size_t getRuleIndex() const override;
1721 : antlr4::tree::TerminalNode *ATTACH();
1722 : antlr4::tree::TerminalNode *LEFT_PAREN();
1723 : Var_listContext *var_list();
1724 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1725 :
1726 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1727 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1728 :
1729 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1730 :
1731 : };
1732 :
1733 : Attach_clauseContext* attach_clause();
1734 :
1735 : class Auto_clauseContext : public antlr4::ParserRuleContext {
1736 : public:
1737 : Auto_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1738 : virtual size_t getRuleIndex() const override;
1739 : antlr4::tree::TerminalNode *AUTO();
1740 :
1741 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1742 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1743 :
1744 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1745 :
1746 : };
1747 :
1748 : Auto_clauseContext* auto_clause();
1749 :
1750 : class Bind_clauseContext : public antlr4::ParserRuleContext {
1751 : public:
1752 : Bind_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1753 : virtual size_t getRuleIndex() const override;
1754 : antlr4::tree::TerminalNode *BIND();
1755 : antlr4::tree::TerminalNode *LEFT_PAREN();
1756 : Name_or_stringContext *name_or_string();
1757 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1758 :
1759 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1760 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1761 :
1762 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1763 :
1764 : };
1765 :
1766 : Bind_clauseContext* bind_clause();
1767 :
1768 : class Name_or_stringContext : public antlr4::ParserRuleContext {
1769 : public:
1770 : Name_or_stringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1771 : virtual size_t getRuleIndex() const override;
1772 : antlr4::tree::TerminalNode *EXPR();
1773 :
1774 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1775 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1776 :
1777 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1778 :
1779 : };
1780 :
1781 : Name_or_stringContext* name_or_string();
1782 :
1783 : class Capture_clauseContext : public antlr4::ParserRuleContext {
1784 : public:
1785 : Capture_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1786 : virtual size_t getRuleIndex() const override;
1787 : antlr4::tree::TerminalNode *CAPTURE();
1788 :
1789 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1790 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1791 :
1792 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1793 :
1794 : };
1795 :
1796 : Capture_clauseContext* capture_clause();
1797 :
1798 : class Collapse_clauseContext : public antlr4::ParserRuleContext {
1799 : public:
1800 : Collapse_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1801 : virtual size_t getRuleIndex() const override;
1802 : antlr4::tree::TerminalNode *COLLAPSE();
1803 : antlr4::tree::TerminalNode *LEFT_PAREN();
1804 : Const_intContext *const_int();
1805 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1806 :
1807 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1808 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1809 :
1810 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1811 :
1812 : };
1813 :
1814 : Collapse_clauseContext* collapse_clause();
1815 :
1816 : class Copy_clauseContext : public antlr4::ParserRuleContext {
1817 : public:
1818 : Copy_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1819 : virtual size_t getRuleIndex() const override;
1820 : antlr4::tree::TerminalNode *COPY();
1821 : antlr4::tree::TerminalNode *LEFT_PAREN();
1822 : Var_listContext *var_list();
1823 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1824 :
1825 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1826 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1827 :
1828 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1829 :
1830 : };
1831 :
1832 : Copy_clauseContext* copy_clause();
1833 :
1834 : class Copyin_clauseContext : public antlr4::ParserRuleContext {
1835 : public:
1836 : Copyin_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1837 : virtual size_t getRuleIndex() const override;
1838 : antlr4::tree::TerminalNode *COPYIN();
1839 : antlr4::tree::TerminalNode *LEFT_PAREN();
1840 : Var_listContext *var_list();
1841 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1842 : Copyin_clause_modifierContext *copyin_clause_modifier();
1843 : antlr4::tree::TerminalNode *COLON();
1844 :
1845 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1846 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1847 :
1848 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1849 :
1850 : };
1851 :
1852 : Copyin_clauseContext* copyin_clause();
1853 :
1854 : class Copyin_clause_modifierContext : public antlr4::ParserRuleContext {
1855 : public:
1856 : Copyin_clause_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1857 : virtual size_t getRuleIndex() const override;
1858 : antlr4::tree::TerminalNode *READONLY();
1859 :
1860 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1861 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1862 :
1863 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1864 :
1865 : };
1866 :
1867 : Copyin_clause_modifierContext* copyin_clause_modifier();
1868 :
1869 : class Copyin_no_modifier_clauseContext : public antlr4::ParserRuleContext {
1870 : public:
1871 : Copyin_no_modifier_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1872 : virtual size_t getRuleIndex() const override;
1873 : antlr4::tree::TerminalNode *COPYIN();
1874 : antlr4::tree::TerminalNode *LEFT_PAREN();
1875 : Var_listContext *var_list();
1876 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1877 :
1878 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1879 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1880 :
1881 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1882 :
1883 : };
1884 :
1885 : Copyin_no_modifier_clauseContext* copyin_no_modifier_clause();
1886 :
1887 : class Copyout_clauseContext : public antlr4::ParserRuleContext {
1888 : public:
1889 : Copyout_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1890 : virtual size_t getRuleIndex() const override;
1891 : antlr4::tree::TerminalNode *COPYOUT();
1892 : antlr4::tree::TerminalNode *LEFT_PAREN();
1893 : Var_listContext *var_list();
1894 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1895 : Copyout_clause_modifierContext *copyout_clause_modifier();
1896 : antlr4::tree::TerminalNode *COLON();
1897 :
1898 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1899 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1900 :
1901 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1902 :
1903 : };
1904 :
1905 : Copyout_clauseContext* copyout_clause();
1906 :
1907 : class Copyout_clause_modifierContext : public antlr4::ParserRuleContext {
1908 : public:
1909 : Copyout_clause_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1910 : virtual size_t getRuleIndex() const override;
1911 : antlr4::tree::TerminalNode *ZERO();
1912 :
1913 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1914 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1915 :
1916 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1917 :
1918 : };
1919 :
1920 : Copyout_clause_modifierContext* copyout_clause_modifier();
1921 :
1922 : class Copyout_no_modifier_clauseContext : public antlr4::ParserRuleContext {
1923 : public:
1924 : Copyout_no_modifier_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1925 : virtual size_t getRuleIndex() const override;
1926 : antlr4::tree::TerminalNode *COPYOUT();
1927 : antlr4::tree::TerminalNode *LEFT_PAREN();
1928 : Var_listContext *var_list();
1929 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1930 :
1931 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1932 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1933 :
1934 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1935 :
1936 : };
1937 :
1938 : Copyout_no_modifier_clauseContext* copyout_no_modifier_clause();
1939 :
1940 : class Create_clauseContext : public antlr4::ParserRuleContext {
1941 : public:
1942 : Create_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1943 : virtual size_t getRuleIndex() const override;
1944 : antlr4::tree::TerminalNode *CREATE();
1945 : antlr4::tree::TerminalNode *LEFT_PAREN();
1946 : Var_listContext *var_list();
1947 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1948 : Create_clause_modifierContext *create_clause_modifier();
1949 : antlr4::tree::TerminalNode *COLON();
1950 :
1951 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1952 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1953 :
1954 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1955 :
1956 : };
1957 :
1958 : Create_clauseContext* create_clause();
1959 :
1960 : class Create_clause_modifierContext : public antlr4::ParserRuleContext {
1961 : public:
1962 : Create_clause_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1963 : virtual size_t getRuleIndex() const override;
1964 : antlr4::tree::TerminalNode *ZERO();
1965 :
1966 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1967 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1968 :
1969 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1970 :
1971 : };
1972 :
1973 : Create_clause_modifierContext* create_clause_modifier();
1974 :
1975 : class Create_no_modifier_clauseContext : public antlr4::ParserRuleContext {
1976 : public:
1977 : Create_no_modifier_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1978 : virtual size_t getRuleIndex() const override;
1979 : antlr4::tree::TerminalNode *CREATE();
1980 : antlr4::tree::TerminalNode *LEFT_PAREN();
1981 : Var_listContext *var_list();
1982 : antlr4::tree::TerminalNode *RIGHT_PAREN();
1983 :
1984 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
1985 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
1986 :
1987 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
1988 :
1989 : };
1990 :
1991 : Create_no_modifier_clauseContext* create_no_modifier_clause();
1992 :
1993 : class Default_clauseContext : public antlr4::ParserRuleContext {
1994 : public:
1995 : Default_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
1996 : virtual size_t getRuleIndex() const override;
1997 : antlr4::tree::TerminalNode *DEFAULT();
1998 : antlr4::tree::TerminalNode *LEFT_PAREN();
1999 : Default_kindContext *default_kind();
2000 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2001 :
2002 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2003 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2004 :
2005 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2006 :
2007 : };
2008 :
2009 : Default_clauseContext* default_clause();
2010 :
2011 : class Default_kindContext : public antlr4::ParserRuleContext {
2012 : public:
2013 : Default_kindContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2014 : virtual size_t getRuleIndex() const override;
2015 : antlr4::tree::TerminalNode *NONE();
2016 : antlr4::tree::TerminalNode *PRESENT();
2017 :
2018 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2019 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2020 :
2021 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2022 :
2023 : };
2024 :
2025 : Default_kindContext* default_kind();
2026 :
2027 : class Default_async_clauseContext : public antlr4::ParserRuleContext {
2028 : public:
2029 : Default_async_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2030 : virtual size_t getRuleIndex() const override;
2031 : antlr4::tree::TerminalNode *DEFAULT_ASYNC();
2032 : antlr4::tree::TerminalNode *LEFT_PAREN();
2033 : Int_exprContext *int_expr();
2034 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2035 :
2036 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2037 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2038 :
2039 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2040 :
2041 : };
2042 :
2043 : Default_async_clauseContext* default_async_clause();
2044 :
2045 : class Delete_clauseContext : public antlr4::ParserRuleContext {
2046 : public:
2047 : Delete_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2048 : virtual size_t getRuleIndex() const override;
2049 : antlr4::tree::TerminalNode *DELETE();
2050 : antlr4::tree::TerminalNode *LEFT_PAREN();
2051 : Var_listContext *var_list();
2052 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2053 :
2054 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2055 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2056 :
2057 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2058 :
2059 : };
2060 :
2061 : Delete_clauseContext* delete_clause();
2062 :
2063 : class Detach_clauseContext : public antlr4::ParserRuleContext {
2064 : public:
2065 : Detach_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2066 : virtual size_t getRuleIndex() const override;
2067 : antlr4::tree::TerminalNode *DETACH();
2068 : antlr4::tree::TerminalNode *LEFT_PAREN();
2069 : Var_listContext *var_list();
2070 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2071 :
2072 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2073 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2074 :
2075 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2076 :
2077 : };
2078 :
2079 : Detach_clauseContext* detach_clause();
2080 :
2081 : class Device_clauseContext : public antlr4::ParserRuleContext {
2082 : public:
2083 : Device_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2084 : virtual size_t getRuleIndex() const override;
2085 : antlr4::tree::TerminalNode *DEVICE();
2086 : antlr4::tree::TerminalNode *LEFT_PAREN();
2087 : Var_listContext *var_list();
2088 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2089 :
2090 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2091 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2092 :
2093 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2094 :
2095 : };
2096 :
2097 : Device_clauseContext* device_clause();
2098 :
2099 : class Device_num_clauseContext : public antlr4::ParserRuleContext {
2100 : public:
2101 : Device_num_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2102 : virtual size_t getRuleIndex() const override;
2103 : antlr4::tree::TerminalNode *DEVICE_NUM();
2104 : antlr4::tree::TerminalNode *LEFT_PAREN();
2105 : Int_exprContext *int_expr();
2106 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2107 :
2108 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2109 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2110 :
2111 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2112 :
2113 : };
2114 :
2115 : Device_num_clauseContext* device_num_clause();
2116 :
2117 : class Device_resident_clauseContext : public antlr4::ParserRuleContext {
2118 : public:
2119 : Device_resident_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2120 : virtual size_t getRuleIndex() const override;
2121 : antlr4::tree::TerminalNode *DEVICE_RESIDENT();
2122 : antlr4::tree::TerminalNode *LEFT_PAREN();
2123 : Var_listContext *var_list();
2124 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2125 :
2126 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2127 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2128 :
2129 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2130 :
2131 : };
2132 :
2133 : Device_resident_clauseContext* device_resident_clause();
2134 :
2135 : class Device_type_clauseContext : public antlr4::ParserRuleContext {
2136 : public:
2137 : Device_type_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2138 : virtual size_t getRuleIndex() const override;
2139 : antlr4::tree::TerminalNode *DEVICE_TYPE();
2140 : antlr4::tree::TerminalNode *LEFT_PAREN();
2141 : Device_type_listContext *device_type_list();
2142 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2143 :
2144 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2145 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2146 :
2147 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2148 :
2149 : };
2150 :
2151 : Device_type_clauseContext* device_type_clause();
2152 :
2153 : class Device_type_listContext : public antlr4::ParserRuleContext {
2154 : public:
2155 : Device_type_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2156 : virtual size_t getRuleIndex() const override;
2157 : std::vector<VarContext *> var();
2158 : VarContext* var(size_t i);
2159 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2160 : antlr4::tree::TerminalNode* COMMA(size_t i);
2161 :
2162 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2163 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2164 :
2165 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2166 :
2167 : };
2168 :
2169 : Device_type_listContext* device_type_list();
2170 :
2171 : class Deviceptr_clauseContext : public antlr4::ParserRuleContext {
2172 : public:
2173 : Deviceptr_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2174 : virtual size_t getRuleIndex() const override;
2175 : antlr4::tree::TerminalNode *DEVICEPTR();
2176 : antlr4::tree::TerminalNode *LEFT_PAREN();
2177 : Var_listContext *var_list();
2178 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2179 :
2180 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2181 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2182 :
2183 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2184 :
2185 : };
2186 :
2187 : Deviceptr_clauseContext* deviceptr_clause();
2188 :
2189 : class Finalize_clauseContext : public antlr4::ParserRuleContext {
2190 : public:
2191 : Finalize_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2192 : virtual size_t getRuleIndex() const override;
2193 : antlr4::tree::TerminalNode *FINALIZE();
2194 :
2195 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2196 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2197 :
2198 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2199 :
2200 : };
2201 :
2202 : Finalize_clauseContext* finalize_clause();
2203 :
2204 : class Firstprivate_clauseContext : public antlr4::ParserRuleContext {
2205 : public:
2206 : Firstprivate_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2207 : virtual size_t getRuleIndex() const override;
2208 : antlr4::tree::TerminalNode *FIRSTPRIVATE();
2209 : antlr4::tree::TerminalNode *LEFT_PAREN();
2210 : Var_listContext *var_list();
2211 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2212 :
2213 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2214 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2215 :
2216 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2217 :
2218 : };
2219 :
2220 : Firstprivate_clauseContext* firstprivate_clause();
2221 :
2222 : class Gang_clauseContext : public antlr4::ParserRuleContext {
2223 : public:
2224 : Gang_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2225 : virtual size_t getRuleIndex() const override;
2226 : antlr4::tree::TerminalNode *GANG();
2227 : antlr4::tree::TerminalNode *LEFT_PAREN();
2228 : Gang_arg_listContext *gang_arg_list();
2229 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2230 :
2231 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2232 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2233 :
2234 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2235 :
2236 : };
2237 :
2238 : Gang_clauseContext* gang_clause();
2239 :
2240 : class Gang_arg_listContext : public antlr4::ParserRuleContext {
2241 : public:
2242 : Gang_arg_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2243 : virtual size_t getRuleIndex() const override;
2244 : std::vector<VarContext *> var();
2245 : VarContext* var(size_t i);
2246 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2247 : antlr4::tree::TerminalNode* COMMA(size_t i);
2248 :
2249 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2250 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2251 :
2252 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2253 :
2254 : };
2255 :
2256 : Gang_arg_listContext* gang_arg_list();
2257 :
2258 : class Gang_no_list_clauseContext : public antlr4::ParserRuleContext {
2259 : public:
2260 : Gang_no_list_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2261 : virtual size_t getRuleIndex() const override;
2262 : antlr4::tree::TerminalNode *GANG();
2263 :
2264 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2265 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2266 :
2267 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2268 :
2269 : };
2270 :
2271 : Gang_no_list_clauseContext* gang_no_list_clause();
2272 :
2273 : class Host_clauseContext : public antlr4::ParserRuleContext {
2274 : public:
2275 : Host_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2276 : virtual size_t getRuleIndex() const override;
2277 : antlr4::tree::TerminalNode *HOST();
2278 : antlr4::tree::TerminalNode *LEFT_PAREN();
2279 : Var_listContext *var_list();
2280 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2281 :
2282 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2283 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2284 :
2285 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2286 :
2287 : };
2288 :
2289 : Host_clauseContext* host_clause();
2290 :
2291 : class If_clauseContext : public antlr4::ParserRuleContext {
2292 : public:
2293 : If_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2294 : virtual size_t getRuleIndex() const override;
2295 : antlr4::tree::TerminalNode *IF();
2296 : antlr4::tree::TerminalNode *LEFT_PAREN();
2297 : ConditionContext *condition();
2298 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2299 :
2300 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2301 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2302 :
2303 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2304 :
2305 : };
2306 :
2307 : If_clauseContext* if_clause();
2308 :
2309 : class If_present_clauseContext : public antlr4::ParserRuleContext {
2310 : public:
2311 : If_present_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2312 : virtual size_t getRuleIndex() const override;
2313 : antlr4::tree::TerminalNode *IF_PRESENT();
2314 :
2315 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2316 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2317 :
2318 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2319 :
2320 : };
2321 :
2322 : If_present_clauseContext* if_present_clause();
2323 :
2324 : class Independent_clauseContext : public antlr4::ParserRuleContext {
2325 : public:
2326 : Independent_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2327 : virtual size_t getRuleIndex() const override;
2328 : antlr4::tree::TerminalNode *INDEPENDENT();
2329 :
2330 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2331 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2332 :
2333 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2334 :
2335 : };
2336 :
2337 : Independent_clauseContext* independent_clause();
2338 :
2339 : class Link_clauseContext : public antlr4::ParserRuleContext {
2340 : public:
2341 : Link_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2342 : virtual size_t getRuleIndex() const override;
2343 : antlr4::tree::TerminalNode *LINK();
2344 : antlr4::tree::TerminalNode *LEFT_PAREN();
2345 : Var_listContext *var_list();
2346 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2347 :
2348 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2349 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2350 :
2351 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2352 :
2353 : };
2354 :
2355 : Link_clauseContext* link_clause();
2356 :
2357 : class Nohost_clauseContext : public antlr4::ParserRuleContext {
2358 : public:
2359 : Nohost_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2360 : virtual size_t getRuleIndex() const override;
2361 : antlr4::tree::TerminalNode *NOHOST();
2362 :
2363 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2364 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2365 :
2366 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2367 :
2368 : };
2369 :
2370 : Nohost_clauseContext* nohost_clause();
2371 :
2372 : class No_create_clauseContext : public antlr4::ParserRuleContext {
2373 : public:
2374 : No_create_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2375 : virtual size_t getRuleIndex() const override;
2376 : antlr4::tree::TerminalNode *NO_CREATE();
2377 : antlr4::tree::TerminalNode *LEFT_PAREN();
2378 : Var_listContext *var_list();
2379 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2380 :
2381 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2382 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2383 :
2384 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2385 :
2386 : };
2387 :
2388 : No_create_clauseContext* no_create_clause();
2389 :
2390 : class Num_gangs_clauseContext : public antlr4::ParserRuleContext {
2391 : public:
2392 : Num_gangs_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2393 : virtual size_t getRuleIndex() const override;
2394 : antlr4::tree::TerminalNode *NUM_GANGS();
2395 : antlr4::tree::TerminalNode *LEFT_PAREN();
2396 : Int_exprContext *int_expr();
2397 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2398 :
2399 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2400 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2401 :
2402 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2403 :
2404 : };
2405 :
2406 : Num_gangs_clauseContext* num_gangs_clause();
2407 :
2408 : class Num_workers_clauseContext : public antlr4::ParserRuleContext {
2409 : public:
2410 : Num_workers_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2411 : virtual size_t getRuleIndex() const override;
2412 : antlr4::tree::TerminalNode *NUM_WORKERS();
2413 : antlr4::tree::TerminalNode *LEFT_PAREN();
2414 : Int_exprContext *int_expr();
2415 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2416 :
2417 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2418 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2419 :
2420 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2421 :
2422 : };
2423 :
2424 : Num_workers_clauseContext* num_workers_clause();
2425 :
2426 : class Present_clauseContext : public antlr4::ParserRuleContext {
2427 : public:
2428 : Present_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2429 : virtual size_t getRuleIndex() const override;
2430 : antlr4::tree::TerminalNode *PRESENT();
2431 : antlr4::tree::TerminalNode *LEFT_PAREN();
2432 : Var_listContext *var_list();
2433 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2434 :
2435 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2436 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2437 :
2438 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2439 :
2440 : };
2441 :
2442 : Present_clauseContext* present_clause();
2443 :
2444 : class Private_clauseContext : public antlr4::ParserRuleContext {
2445 : public:
2446 : Private_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2447 : virtual size_t getRuleIndex() const override;
2448 : antlr4::tree::TerminalNode *PRIVATE();
2449 : antlr4::tree::TerminalNode *LEFT_PAREN();
2450 : Var_listContext *var_list();
2451 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2452 :
2453 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2454 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2455 :
2456 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2457 :
2458 : };
2459 :
2460 : Private_clauseContext* private_clause();
2461 :
2462 : class Read_clauseContext : public antlr4::ParserRuleContext {
2463 : public:
2464 : Read_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2465 : virtual size_t getRuleIndex() const override;
2466 : antlr4::tree::TerminalNode *READ();
2467 :
2468 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2469 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2470 :
2471 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2472 :
2473 : };
2474 :
2475 : Read_clauseContext* read_clause();
2476 :
2477 : class Reduction_clauseContext : public antlr4::ParserRuleContext {
2478 : public:
2479 : Reduction_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2480 : virtual size_t getRuleIndex() const override;
2481 : antlr4::tree::TerminalNode *REDUCTION();
2482 : antlr4::tree::TerminalNode *LEFT_PAREN();
2483 : Reduction_operatorContext *reduction_operator();
2484 : antlr4::tree::TerminalNode *COLON();
2485 : Var_listContext *var_list();
2486 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2487 :
2488 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2489 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2490 :
2491 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2492 :
2493 : };
2494 :
2495 : Reduction_clauseContext* reduction_clause();
2496 :
2497 : class Reduction_operatorContext : public antlr4::ParserRuleContext {
2498 : public:
2499 : Reduction_operatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2500 : virtual size_t getRuleIndex() const override;
2501 : antlr4::tree::TerminalNode *ADD();
2502 : antlr4::tree::TerminalNode *MUL();
2503 : antlr4::tree::TerminalNode *MAX();
2504 : antlr4::tree::TerminalNode *MIN();
2505 : antlr4::tree::TerminalNode *BITAND();
2506 : antlr4::tree::TerminalNode *BITOR();
2507 : antlr4::tree::TerminalNode *BITXOR();
2508 : antlr4::tree::TerminalNode *LOGAND();
2509 : antlr4::tree::TerminalNode *LOGOR();
2510 :
2511 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2512 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2513 :
2514 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2515 :
2516 : };
2517 :
2518 : Reduction_operatorContext* reduction_operator();
2519 :
2520 : class Self_clauseContext : public antlr4::ParserRuleContext {
2521 : public:
2522 : Self_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2523 : virtual size_t getRuleIndex() const override;
2524 : antlr4::tree::TerminalNode *SELF();
2525 : antlr4::tree::TerminalNode *LEFT_PAREN();
2526 : ConditionContext *condition();
2527 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2528 :
2529 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2530 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2531 :
2532 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2533 :
2534 : };
2535 :
2536 : Self_clauseContext* self_clause();
2537 :
2538 : class Self_list_clauseContext : public antlr4::ParserRuleContext {
2539 : public:
2540 : Self_list_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2541 : virtual size_t getRuleIndex() const override;
2542 : antlr4::tree::TerminalNode *SELF();
2543 : antlr4::tree::TerminalNode *LEFT_PAREN();
2544 : Var_listContext *var_list();
2545 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2546 :
2547 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2548 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2549 :
2550 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2551 :
2552 : };
2553 :
2554 : Self_list_clauseContext* self_list_clause();
2555 :
2556 : class ConditionContext : public antlr4::ParserRuleContext {
2557 : public:
2558 : ConditionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2559 : virtual size_t getRuleIndex() const override;
2560 : antlr4::tree::TerminalNode *EXPR();
2561 :
2562 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2563 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2564 :
2565 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2566 :
2567 : };
2568 :
2569 : ConditionContext* condition();
2570 :
2571 : class Seq_clauseContext : public antlr4::ParserRuleContext {
2572 : public:
2573 : Seq_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2574 : virtual size_t getRuleIndex() const override;
2575 : antlr4::tree::TerminalNode *SEQ();
2576 :
2577 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2578 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2579 :
2580 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2581 :
2582 : };
2583 :
2584 : Seq_clauseContext* seq_clause();
2585 :
2586 : class Tile_clauseContext : public antlr4::ParserRuleContext {
2587 : public:
2588 : Tile_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2589 : virtual size_t getRuleIndex() const override;
2590 : antlr4::tree::TerminalNode *TILE();
2591 : antlr4::tree::TerminalNode *LEFT_PAREN();
2592 : Size_expr_listContext *size_expr_list();
2593 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2594 :
2595 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2596 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2597 :
2598 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2599 :
2600 : };
2601 :
2602 : Tile_clauseContext* tile_clause();
2603 :
2604 : class Update_clauseContext : public antlr4::ParserRuleContext {
2605 : public:
2606 : Update_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2607 : virtual size_t getRuleIndex() const override;
2608 : antlr4::tree::TerminalNode *UPDATE();
2609 :
2610 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2611 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2612 :
2613 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2614 :
2615 : };
2616 :
2617 : Update_clauseContext* update_clause();
2618 :
2619 : class Size_expr_listContext : public antlr4::ParserRuleContext {
2620 : public:
2621 : Size_expr_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2622 : virtual size_t getRuleIndex() const override;
2623 : std::vector<VarContext *> var();
2624 : VarContext* var(size_t i);
2625 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2626 : antlr4::tree::TerminalNode* COMMA(size_t i);
2627 :
2628 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2629 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2630 :
2631 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2632 :
2633 : };
2634 :
2635 : Size_expr_listContext* size_expr_list();
2636 :
2637 : class Use_device_clauseContext : public antlr4::ParserRuleContext {
2638 : public:
2639 : Use_device_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2640 : virtual size_t getRuleIndex() const override;
2641 : antlr4::tree::TerminalNode *USE_DEVICE();
2642 : antlr4::tree::TerminalNode *LEFT_PAREN();
2643 : Var_listContext *var_list();
2644 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2645 :
2646 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2647 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2648 :
2649 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2650 :
2651 : };
2652 :
2653 : Use_device_clauseContext* use_device_clause();
2654 :
2655 : class Vector_clauseContext : public antlr4::ParserRuleContext {
2656 : public:
2657 : Vector_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2658 : virtual size_t getRuleIndex() const override;
2659 : antlr4::tree::TerminalNode *VECTOR();
2660 : Vector_clause_argsContext *vector_clause_args();
2661 :
2662 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2663 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2664 :
2665 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2666 :
2667 : };
2668 :
2669 : Vector_clauseContext* vector_clause();
2670 :
2671 : class Vector_clause_argsContext : public antlr4::ParserRuleContext {
2672 : public:
2673 : Vector_clause_argsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2674 : virtual size_t getRuleIndex() const override;
2675 : antlr4::tree::TerminalNode *LEFT_PAREN();
2676 : Vector_clause_modifierContext *vector_clause_modifier();
2677 : antlr4::tree::TerminalNode *COLON();
2678 : Int_exprContext *int_expr();
2679 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2680 :
2681 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2682 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2683 :
2684 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2685 :
2686 : };
2687 :
2688 : Vector_clause_argsContext* vector_clause_args();
2689 :
2690 : class Vector_clause_modifierContext : public antlr4::ParserRuleContext {
2691 : public:
2692 : Vector_clause_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2693 : virtual size_t getRuleIndex() const override;
2694 : antlr4::tree::TerminalNode *LENGTH();
2695 :
2696 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2697 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2698 :
2699 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2700 :
2701 : };
2702 :
2703 : Vector_clause_modifierContext* vector_clause_modifier();
2704 :
2705 : class Vector_no_modifier_clauseContext : public antlr4::ParserRuleContext {
2706 : public:
2707 : Vector_no_modifier_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2708 : virtual size_t getRuleIndex() const override;
2709 : antlr4::tree::TerminalNode *VECTOR();
2710 :
2711 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2712 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2713 :
2714 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2715 :
2716 : };
2717 :
2718 : Vector_no_modifier_clauseContext* vector_no_modifier_clause();
2719 :
2720 : class Vector_length_clauseContext : public antlr4::ParserRuleContext {
2721 : public:
2722 : Vector_length_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2723 : virtual size_t getRuleIndex() const override;
2724 : antlr4::tree::TerminalNode *VECTOR_LENGTH();
2725 : antlr4::tree::TerminalNode *LEFT_PAREN();
2726 : Int_exprContext *int_expr();
2727 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2728 :
2729 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2730 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2731 :
2732 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2733 :
2734 : };
2735 :
2736 : Vector_length_clauseContext* vector_length_clause();
2737 :
2738 : class Wait_clauseContext : public antlr4::ParserRuleContext {
2739 : public:
2740 : Wait_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2741 : virtual size_t getRuleIndex() const override;
2742 : antlr4::tree::TerminalNode *WAIT();
2743 : antlr4::tree::TerminalNode *LEFT_PAREN();
2744 : Int_expr_listContext *int_expr_list();
2745 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2746 :
2747 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2748 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2749 :
2750 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2751 :
2752 : };
2753 :
2754 : Wait_clauseContext* wait_clause();
2755 :
2756 : class Wait_argument_clauseContext : public antlr4::ParserRuleContext {
2757 : public:
2758 : Wait_argument_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2759 : virtual size_t getRuleIndex() const override;
2760 : antlr4::tree::TerminalNode *WAIT();
2761 : antlr4::tree::TerminalNode *LEFT_PAREN();
2762 : Wait_argumentContext *wait_argument();
2763 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2764 :
2765 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2766 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2767 :
2768 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2769 :
2770 : };
2771 :
2772 : Wait_argument_clauseContext* wait_argument_clause();
2773 :
2774 : class Wait_argumentContext : public antlr4::ParserRuleContext {
2775 : public:
2776 : Wait_argumentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2777 : virtual size_t getRuleIndex() const override;
2778 : antlr4::tree::TerminalNode *DEVNUM();
2779 : std::vector<antlr4::tree::TerminalNode *> COLON();
2780 : antlr4::tree::TerminalNode* COLON(size_t i);
2781 : Wait_argument_int_exprContext *wait_argument_int_expr();
2782 : Wait_argument_queuesContext *wait_argument_queues();
2783 : Wait_int_expr_listContext *wait_int_expr_list();
2784 :
2785 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2786 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2787 :
2788 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2789 :
2790 : };
2791 :
2792 : Wait_argumentContext* wait_argument();
2793 :
2794 : class Wait_int_expr_listContext : public antlr4::ParserRuleContext {
2795 : public:
2796 : Wait_int_expr_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2797 : virtual size_t getRuleIndex() const override;
2798 : std::vector<Wait_int_exprContext *> wait_int_expr();
2799 : Wait_int_exprContext* wait_int_expr(size_t i);
2800 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2801 : antlr4::tree::TerminalNode* COMMA(size_t i);
2802 :
2803 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2804 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2805 :
2806 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2807 :
2808 : };
2809 :
2810 : Wait_int_expr_listContext* wait_int_expr_list();
2811 :
2812 : class Wait_int_exprContext : public antlr4::ParserRuleContext {
2813 : public:
2814 : Wait_int_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2815 : virtual size_t getRuleIndex() const override;
2816 : antlr4::tree::TerminalNode *EXPR();
2817 :
2818 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2819 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2820 :
2821 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2822 :
2823 : };
2824 :
2825 : Wait_int_exprContext* wait_int_expr();
2826 :
2827 : class Wait_argument_queuesContext : public antlr4::ParserRuleContext {
2828 : public:
2829 : Wait_argument_queuesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2830 : virtual size_t getRuleIndex() const override;
2831 : antlr4::tree::TerminalNode *QUEUES();
2832 :
2833 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2834 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2835 :
2836 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2837 :
2838 : };
2839 :
2840 : Wait_argument_queuesContext* wait_argument_queues();
2841 :
2842 : class Wait_argument_int_exprContext : public antlr4::ParserRuleContext {
2843 : public:
2844 : Wait_argument_int_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2845 : virtual size_t getRuleIndex() const override;
2846 : antlr4::tree::TerminalNode *EXPR();
2847 :
2848 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2849 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2850 :
2851 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2852 :
2853 : };
2854 :
2855 : Wait_argument_int_exprContext* wait_argument_int_expr();
2856 :
2857 : class Worker_clauseContext : public antlr4::ParserRuleContext {
2858 : public:
2859 : Worker_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2860 : virtual size_t getRuleIndex() const override;
2861 : antlr4::tree::TerminalNode *WORKER();
2862 : Worker_clause_argsContext *worker_clause_args();
2863 :
2864 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2865 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2866 :
2867 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2868 :
2869 : };
2870 :
2871 : Worker_clauseContext* worker_clause();
2872 :
2873 : class Worker_clause_argsContext : public antlr4::ParserRuleContext {
2874 : public:
2875 : Worker_clause_argsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2876 : virtual size_t getRuleIndex() const override;
2877 : antlr4::tree::TerminalNode *LEFT_PAREN();
2878 : Worker_clause_modifierContext *worker_clause_modifier();
2879 : antlr4::tree::TerminalNode *COLON();
2880 : Int_exprContext *int_expr();
2881 : antlr4::tree::TerminalNode *RIGHT_PAREN();
2882 :
2883 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2884 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2885 :
2886 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2887 :
2888 : };
2889 :
2890 : Worker_clause_argsContext* worker_clause_args();
2891 :
2892 : class Worker_clause_modifierContext : public antlr4::ParserRuleContext {
2893 : public:
2894 : Worker_clause_modifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2895 : virtual size_t getRuleIndex() const override;
2896 : antlr4::tree::TerminalNode *NUM();
2897 :
2898 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2899 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2900 :
2901 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2902 :
2903 : };
2904 :
2905 : Worker_clause_modifierContext* worker_clause_modifier();
2906 :
2907 : class Worker_no_modifier_clauseContext : public antlr4::ParserRuleContext {
2908 : public:
2909 : Worker_no_modifier_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2910 : virtual size_t getRuleIndex() const override;
2911 : antlr4::tree::TerminalNode *WORKER();
2912 :
2913 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2914 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2915 :
2916 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2917 :
2918 : };
2919 :
2920 : Worker_no_modifier_clauseContext* worker_no_modifier_clause();
2921 :
2922 : class Write_clauseContext : public antlr4::ParserRuleContext {
2923 : public:
2924 : Write_clauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2925 : virtual size_t getRuleIndex() const override;
2926 : antlr4::tree::TerminalNode *WRITE();
2927 :
2928 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2929 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2930 :
2931 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2932 :
2933 : };
2934 :
2935 : Write_clauseContext* write_clause();
2936 :
2937 : class Const_intContext : public antlr4::ParserRuleContext {
2938 : public:
2939 : Const_intContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2940 : virtual size_t getRuleIndex() const override;
2941 : antlr4::tree::TerminalNode *EXPR();
2942 :
2943 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2944 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2945 :
2946 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2947 :
2948 : };
2949 :
2950 : Const_intContext* const_int();
2951 :
2952 : class Int_expr_listContext : public antlr4::ParserRuleContext {
2953 : public:
2954 : Int_expr_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2955 : virtual size_t getRuleIndex() const override;
2956 : std::vector<Int_exprContext *> int_expr();
2957 : Int_exprContext* int_expr(size_t i);
2958 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2959 : antlr4::tree::TerminalNode* COMMA(size_t i);
2960 :
2961 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2962 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2963 :
2964 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2965 :
2966 : };
2967 :
2968 : Int_expr_listContext* int_expr_list();
2969 :
2970 : class Int_exprContext : public antlr4::ParserRuleContext {
2971 : public:
2972 : Int_exprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2973 : virtual size_t getRuleIndex() const override;
2974 : antlr4::tree::TerminalNode *EXPR();
2975 :
2976 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2977 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2978 :
2979 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2980 :
2981 : };
2982 :
2983 : Int_exprContext* int_expr();
2984 :
2985 : class Var_listContext : public antlr4::ParserRuleContext {
2986 : public:
2987 : Var_listContext(antlr4::ParserRuleContext *parent, size_t invokingState);
2988 : virtual size_t getRuleIndex() const override;
2989 : std::vector<VarContext *> var();
2990 : VarContext* var(size_t i);
2991 : std::vector<antlr4::tree::TerminalNode *> COMMA();
2992 : antlr4::tree::TerminalNode* COMMA(size_t i);
2993 :
2994 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
2995 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
2996 :
2997 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
2998 :
2999 : };
3000 :
3001 : Var_listContext* var_list();
3002 :
3003 : class VarContext : public antlr4::ParserRuleContext {
3004 : public:
3005 : VarContext(antlr4::ParserRuleContext *parent, size_t invokingState);
3006 : virtual size_t getRuleIndex() const override;
3007 : antlr4::tree::TerminalNode *EXPR();
3008 :
3009 : virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
3010 : virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
3011 :
3012 : virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
3013 :
3014 : };
3015 :
3016 : VarContext* var();
3017 :
3018 :
3019 : private:
3020 : static std::vector<antlr4::dfa::DFA> _decisionToDFA;
3021 : static antlr4::atn::PredictionContextCache _sharedContextCache;
3022 : static std::vector<std::string> _ruleNames;
3023 : static std::vector<std::string> _tokenNames;
3024 :
3025 : static std::vector<std::string> _literalNames;
3026 : static std::vector<std::string> _symbolicNames;
3027 : static antlr4::dfa::Vocabulary _vocabulary;
3028 : static antlr4::atn::ATN _atn;
3029 : static std::vector<uint16_t> _serializedATN;
3030 :
3031 : /* private parser declarations section */
3032 :
3033 : struct Initializer {
3034 : Initializer();
3035 : };
3036 : static Initializer _init;
3037 : };
3038 :
|
