source: src/AST/Stmt.hpp@ 006d4c4

Last change on this file since 006d4c4 was 525f7ad, checked in by JiadaL <j82liang@…>, 15 months ago
  1. Add count_e( enum_name ), a pseudo function that return the number of element in an enum; 2. Implementation of enum range loop.
  • Property mode set to 100644
File size: 18.9 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Stmt.hpp --
8//
9// Author : Aaron B. Moss
10// Created On : Wed May 8 13:00:00 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Apr 5 10:34:00 2023
13// Update Count : 37
14//
15
16#pragma once
17
18#include <list>
19#include <utility> // for move
20#include <vector>
21
22#include "Label.hpp"
23#include "Node.hpp" // for node, ptr
24#include "ParseNode.hpp"
25#include "Visitor.hpp"
26#include "Common/CodeLocation.hpp"
27
28// Must be included in *all* AST classes; should be #undef'd at the end of the file
29#define MUTATE_FRIEND \
30 template<typename node_t> friend node_t * mutate(const node_t * node); \
31 template<typename node_t> friend node_t * shallowCopy(const node_t * node);
32
33namespace ast {
34class Expr;
35
36// Base statement node
37class Stmt : public ParseNode {
38 public:
39 std::vector<Label> labels;
40
41 Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
42 : ParseNode(loc), labels(std::move(labels)) {}
43
44 Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}
45
46 const Stmt * accept( Visitor & v ) const override = 0;
47 private:
48 Stmt * clone() const override = 0;
49 MUTATE_FRIEND
50};
51
52// Base statement component node (only serves to group them).
53class StmtClause : public ParseNode {
54 public:
55 // This is for non-statements that still belong with the statements,
56 // but are not statements, usually some sort of clause. Often these can
57 // (and should) be folded into the approprate parent node, but if they
58 // cannot be, they are sub-types of this type, for organization.
59
60 StmtClause( const CodeLocation & loc )
61 : ParseNode(loc) {}
62
63 private:
64 StmtClause * clone() const override = 0;
65 MUTATE_FRIEND
66};
67
68// Compound statement: { ... }
69class CompoundStmt final : public Stmt {
70 public:
71 std::list<ptr<Stmt>> kids;
72
73 CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
74 : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
75
76 CompoundStmt( const CompoundStmt & o );
77 CompoundStmt( CompoundStmt && o ) = default;
78
79 void push_back( const Stmt * s ) { kids.emplace_back( s ); }
80 void push_front( const Stmt * s ) { kids.emplace_front( s ); }
81
82 const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
83 private:
84 CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
85 MUTATE_FRIEND
86};
87
88// Empty statment: ;
89class NullStmt final : public Stmt {
90 public:
91 NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
92 : Stmt(loc, std::move(labels)) {}
93
94 const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
95 private:
96 NullStmt * clone() const override { return new NullStmt{ *this }; }
97 MUTATE_FRIEND
98};
99
100// Expression wrapped by statement
101class ExprStmt final : public Stmt {
102 public:
103 ptr<Expr> expr;
104
105 ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
106 : Stmt(loc, std::move(labels)), expr(e) {}
107
108 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
109 private:
110 ExprStmt * clone() const override { return new ExprStmt{ *this }; }
111 MUTATE_FRIEND
112};
113
114// Assembly statement: asm ... ( "..." : ... )
115class AsmStmt final : public Stmt {
116 public:
117 bool isVolatile;
118 ptr<Expr> instruction;
119 std::vector<ptr<Expr>> output, input;
120 std::vector<ptr<ConstantExpr>> clobber;
121 std::vector<Label> gotoLabels;
122
123 AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
124 const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
125 const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
126 const std::vector<Label> && labels = {})
127 : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
128 output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
129 gotoLabels(std::move(gotoLabels)) {}
130
131 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
132 private:
133 AsmStmt * clone() const override { return new AsmStmt{ *this }; }
134 MUTATE_FRIEND
135};
136
137// C-preprocessor directive: #...
138class DirectiveStmt final : public Stmt {
139 public:
140 std::string directive;
141
142 DirectiveStmt( const CodeLocation & loc, const std::string & directive,
143 std::vector<Label> && labels = {} )
144 : Stmt(loc, std::move(labels)), directive(directive) {}
145
146 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
147 private:
148 DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
149 MUTATE_FRIEND
150};
151
152// If statement: if (...) ... else ...
153class IfStmt final : public Stmt {
154 public:
155 ptr<Expr> cond;
156 ptr<Stmt> then;
157 ptr<Stmt> else_;
158 std::vector<ptr<Stmt>> inits;
159
160 IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
161 const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
162 const std::vector<Label> && labels = {} )
163 : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
164 inits(std::move(inits)) {}
165
166 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
167 private:
168 IfStmt * clone() const override { return new IfStmt{ *this }; }
169 MUTATE_FRIEND
170};
171
172// Switch or choose statement: switch (...) { ... }
173class SwitchStmt final : public Stmt {
174 public:
175 ptr<Expr> cond;
176 std::vector<ptr<CaseClause>> cases;
177
178 SwitchStmt( const CodeLocation & loc, const Expr * cond,
179 const std::vector<ptr<CaseClause>> && cases,
180 const std::vector<Label> && labels = {} )
181 : Stmt(loc, std::move(labels)), cond(cond), cases(std::move(cases)) {}
182
183 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
184 private:
185 SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
186 MUTATE_FRIEND
187};
188
189// Case label: case ...: or default:
190class CaseClause final : public StmtClause {
191 public:
192 // Null for the default label.
193 ptr<Expr> cond;
194 std::vector<ptr<Stmt>> stmts;
195
196 CaseClause( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts )
197 : StmtClause(loc), cond(cond), stmts(std::move(stmts)) {}
198
199 bool isDefault() const { return !cond; }
200
201 const CaseClause * accept( Visitor & v ) const override { return v.visit( this ); }
202 private:
203 CaseClause * clone() const override { return new CaseClause{ *this }; }
204 MUTATE_FRIEND
205};
206
207// A while loop or a do-while loop:
208enum WhileDoKind { While, DoWhile };
209
210// While loop: while (...) ... else ... or do ... while (...) else ...;
211class WhileDoStmt final : public Stmt {
212 public:
213 ptr<Expr> cond;
214 ptr<Stmt> body;
215 ptr<Stmt> else_;
216 std::vector<ptr<Stmt>> inits;
217 WhileDoKind isDoWhile;
218
219 WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
220 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
221 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
222
223 WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
224 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
225 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
226
227 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
228 private:
229 WhileDoStmt * clone() const override { return new WhileDoStmt{ *this }; }
230 MUTATE_FRIEND
231};
232
233// For loop: for (... ; ... ; ...) ... else ...
234class ForStmt final : public Stmt {
235 public:
236 std::vector<ptr<Stmt>> inits;
237 ptr<Expr> cond;
238 ptr<Expr> inc;
239 ptr<Expr> range_over;
240 ptr<Stmt> body;
241 ptr<Stmt> else_;
242
243 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
244 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
245 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc),
246 range_over(nullptr), body(body), else_(nullptr) {}
247
248 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
249 const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
250 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
251 range_over(nullptr), body(body), else_(else_) {}
252
253 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over,
254 const Stmt * body, const Stmt * else_ )
255 : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), body(body), else_(else_) {}
256
257 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
258 private:
259 ForStmt * clone() const override { return new ForStmt{ *this }; }
260 MUTATE_FRIEND
261};
262
263// Branch control flow statement: goto ... or break or continue or fallthru
264class BranchStmt final : public Stmt {
265 public:
266 enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
267 static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
268
269 const Label originalTarget;
270 Label target;
271 ptr<Expr> computedTarget;
272 Kind kind;
273
274 BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
275 BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
276 : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
277
278 const char * kindName() const { return kindNames[kind]; }
279
280 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
281 private:
282 BranchStmt * clone() const override { return new BranchStmt{ *this }; }
283 MUTATE_FRIEND
284
285 static const char * kindNames[kindEnd];
286};
287
288// Return statement: return ...
289class ReturnStmt final : public Stmt {
290 public:
291 ptr<Expr> expr;
292
293 ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
294 : Stmt(loc, std::move(labels)), expr(expr) {}
295
296 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
297 private:
298 ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
299 MUTATE_FRIEND
300};
301
302// Kind of exception
303enum ExceptionKind { Terminate, Resume };
304
305// Throw statement: throw ...
306class ThrowStmt final : public Stmt {
307 public:
308 ptr<Expr> expr;
309 ptr<Expr> target;
310 ExceptionKind kind;
311
312 ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
313 const Expr * target, const std::vector<Label> && labels = {} )
314 : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
315
316 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
317 private:
318 ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
319 MUTATE_FRIEND
320};
321
322// Try statement: try { ... } ...
323class TryStmt final : public Stmt {
324 public:
325 ptr<CompoundStmt> body;
326 std::vector<ptr<CatchClause>> handlers;
327 ptr<FinallyClause> finally;
328
329 TryStmt( const CodeLocation & loc, const CompoundStmt * body,
330 const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
331 const std::vector<Label> && labels = {} )
332 : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
333
334 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
335 private:
336 TryStmt * clone() const override { return new TryStmt{ *this }; }
337 MUTATE_FRIEND
338};
339
340// Catch clause of try statement
341class CatchClause final : public StmtClause {
342 public:
343 ptr<Decl> decl;
344 ptr<Expr> cond;
345 ptr<Stmt> body;
346 ExceptionKind kind;
347
348 CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
349 const Stmt * body )
350 : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
351
352 const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
353 private:
354 CatchClause * clone() const override { return new CatchClause{ *this }; }
355 MUTATE_FRIEND
356};
357
358// Finally clause of try statement
359class FinallyClause final : public StmtClause {
360 public:
361 ptr<CompoundStmt> body;
362
363 FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
364 : StmtClause(loc), body(body) {}
365
366 const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
367 private:
368 FinallyClause * clone() const override { return new FinallyClause{ *this }; }
369 MUTATE_FRIEND
370};
371
372// Suspend statement
373class SuspendStmt final : public Stmt {
374 public:
375 ptr<CompoundStmt> then;
376 enum Kind { None, Coroutine, Generator } kind = None;
377
378 SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
379 : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
380
381 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
382 private:
383 SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
384 MUTATE_FRIEND
385};
386
387// Base class of WaitFor/WaitUntil statements
388// form: KEYWORD(...) ... timeout(...) ... else ...
389class WaitStmt : public Stmt {
390 public:
391 ptr<Expr> timeout_time;
392 ptr<Stmt> timeout_stmt;
393 ptr<Expr> timeout_cond;
394 ptr<Stmt> else_stmt;
395 ptr<Expr> else_cond;
396
397 WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
398 : Stmt(loc, std::move(labels)) {}
399
400 private:
401 WaitStmt * clone() const override = 0;
402 MUTATE_FRIEND
403};
404
405// Base class for WaitFor/WaitUntil clauses
406// form: when( when_cond ) KEYWORD( target ) stmt
407class WhenClause : public StmtClause {
408 public:
409 ptr<Expr> target;
410 ptr<Stmt> stmt;
411 ptr<Expr> when_cond;
412
413 WhenClause( const CodeLocation & loc )
414 : StmtClause( loc ) {}
415
416 const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
417 private:
418 WhenClause * clone() const override { return new WhenClause{ *this }; }
419 MUTATE_FRIEND
420};
421
422// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
423class WaitForStmt final : public WaitStmt {
424 public:
425 std::vector<ptr<WaitForClause>> clauses;
426
427 WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
428 : WaitStmt(loc, std::move(labels)) {}
429
430 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
431 private:
432 WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
433 MUTATE_FRIEND
434};
435
436// Clause in a waitfor statement: waitfor (..., ...) ...
437class WaitForClause final : public WhenClause {
438 public:
439 std::vector<ptr<Expr>> target_args;
440
441 WaitForClause( const CodeLocation & loc )
442 : WhenClause( loc ) {}
443
444 const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
445 private:
446 WaitForClause * clone() const override { return new WaitForClause{ *this }; }
447 MUTATE_FRIEND
448};
449
450// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
451class WaitUntilStmt final : public WaitStmt {
452 public:
453 // Non-ast node used during compilation to store data needed to generate predicates
454 // and set initial status values for clauses
455 // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
456 struct ClauseNode {
457 enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
458 // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
459
460 ClauseNode * left;
461 ClauseNode * right;
462 WhenClause * leaf; // only set if this node is a leaf (points into vector of clauses)
463
464 bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
465 bool whenState; // used to track if when_cond is toggled on or off for generating init values
466 bool childOfAnd; // true on leaf nodes that are children of AND, false otherwise
467
468 ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
469 : op(op), left(left), right(right), leaf(nullptr),
470 ambiguousWhen(false), whenState(true), childOfAnd(false) {}
471 ClauseNode( Op op, WhenClause * leaf )
472 : op(op), left(nullptr), right(nullptr), leaf(leaf),
473 ambiguousWhen(false), whenState(true), childOfAnd(false) {}
474 ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
475
476 ~ClauseNode() {
477 if ( left ) delete left;
478 if ( right ) delete right;
479 }
480 };
481
482 std::vector<ptr<WhenClause>> clauses;
483 ClauseNode * predicateTree;
484
485 WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
486 : WaitStmt(loc, std::move(labels)) {}
487
488 ~WaitUntilStmt() { delete predicateTree; }
489
490 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
491 private:
492 WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
493 MUTATE_FRIEND
494};
495
496// Any declaration in a (compound) statement.
497class DeclStmt final : public Stmt {
498 public:
499 ptr<Decl> decl;
500
501 DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
502 : Stmt(loc, std::move(labels)), decl(decl) {}
503
504 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
505 private:
506 DeclStmt * clone() const override { return new DeclStmt{ *this }; }
507 MUTATE_FRIEND
508};
509
510// Represents an implicit application of a constructor or destructor.
511class ImplicitCtorDtorStmt final : public Stmt {
512 public:
513 ptr<Stmt> callStmt;
514
515 ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
516 std::vector<Label> && labels = {} )
517 : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
518
519 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
520 private:
521 ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
522 MUTATE_FRIEND
523};
524
525// Mutex Statement
526class MutexStmt final : public Stmt {
527 public:
528 ptr<Stmt> stmt;
529 std::vector<ptr<Expr>> mutexObjs;
530
531 MutexStmt( const CodeLocation & loc, const Stmt * stmt,
532 const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
533 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
534
535 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
536 private:
537 MutexStmt * clone() const override { return new MutexStmt{ *this }; }
538 MUTATE_FRIEND
539};
540
541// Corun Statement
542class CorunStmt final : public Stmt {
543 public:
544 ptr<Stmt> stmt;
545
546 CorunStmt( const CodeLocation & loc, const Stmt * stmt, const std::vector<Label> && labels = {} )
547 : Stmt(loc, std::move(labels)), stmt(stmt) {}
548
549 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
550 private:
551 CorunStmt * clone() const override { return new CorunStmt{ *this }; }
552 MUTATE_FRIEND
553};
554
555// Corun Statement
556class CoforStmt final : public Stmt {
557 public:
558 std::vector<ptr<Stmt>> inits;
559 ptr<Expr> cond;
560 ptr<Expr> inc;
561 ptr<Stmt> body;
562
563 CoforStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
564 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
565 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
566
567 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
568 private:
569 CoforStmt * clone() const override { return new CoforStmt{ *this }; }
570 MUTATE_FRIEND
571};
572
573} // namespace ast
574
575#undef MUTATE_FRIEND
576
577// Local Variables: //
578// mode: c++ //
579// End: //
Note: See TracBrowser for help on using the repository browser.