source: src/AST/Stmt.hpp@ 3f37f5b

Last change on this file since 3f37f5b was d3aa55e9, checked in by JiadaL <j82liang@…>, 16 months ago
  1. Disallow implicit conversion from cfa enum to int during on the function call site; 2. implement the reverse enum loop
  • Property mode set to 100644
File size: 19.0 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 bool is_inc;
241 ptr<Stmt> body;
242 ptr<Stmt> else_;
243
244 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
245 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
246 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc),
247 range_over(nullptr), body(body), else_(nullptr) {}
248
249 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
250 const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
251 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
252 range_over(nullptr), body(body), else_(else_) {}
253
254 ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, bool is_inc,
255 const Stmt * body, const Stmt * else_ )
256 : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), is_inc(is_inc),
257 body(body), else_(else_) {}
258
259 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
260 private:
261 ForStmt * clone() const override { return new ForStmt{ *this }; }
262 MUTATE_FRIEND
263};
264
265// Branch control flow statement: goto ... or break or continue or fallthru
266class BranchStmt final : public Stmt {
267 public:
268 enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
269 static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
270
271 const Label originalTarget;
272 Label target;
273 ptr<Expr> computedTarget;
274 Kind kind;
275
276 BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
277 BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
278 : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
279
280 const char * kindName() const { return kindNames[kind]; }
281
282 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
283 private:
284 BranchStmt * clone() const override { return new BranchStmt{ *this }; }
285 MUTATE_FRIEND
286
287 static const char * kindNames[kindEnd];
288};
289
290// Return statement: return ...
291class ReturnStmt final : public Stmt {
292 public:
293 ptr<Expr> expr;
294
295 ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
296 : Stmt(loc, std::move(labels)), expr(expr) {}
297
298 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
299 private:
300 ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
301 MUTATE_FRIEND
302};
303
304// Kind of exception
305enum ExceptionKind { Terminate, Resume };
306
307// Throw statement: throw ...
308class ThrowStmt final : public Stmt {
309 public:
310 ptr<Expr> expr;
311 ptr<Expr> target;
312 ExceptionKind kind;
313
314 ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
315 const Expr * target, const std::vector<Label> && labels = {} )
316 : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
317
318 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
319 private:
320 ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
321 MUTATE_FRIEND
322};
323
324// Try statement: try { ... } ...
325class TryStmt final : public Stmt {
326 public:
327 ptr<CompoundStmt> body;
328 std::vector<ptr<CatchClause>> handlers;
329 ptr<FinallyClause> finally;
330
331 TryStmt( const CodeLocation & loc, const CompoundStmt * body,
332 const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
333 const std::vector<Label> && labels = {} )
334 : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
335
336 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
337 private:
338 TryStmt * clone() const override { return new TryStmt{ *this }; }
339 MUTATE_FRIEND
340};
341
342// Catch clause of try statement
343class CatchClause final : public StmtClause {
344 public:
345 ptr<Decl> decl;
346 ptr<Expr> cond;
347 ptr<Stmt> body;
348 ExceptionKind kind;
349
350 CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
351 const Stmt * body )
352 : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
353
354 const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
355 private:
356 CatchClause * clone() const override { return new CatchClause{ *this }; }
357 MUTATE_FRIEND
358};
359
360// Finally clause of try statement
361class FinallyClause final : public StmtClause {
362 public:
363 ptr<CompoundStmt> body;
364
365 FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
366 : StmtClause(loc), body(body) {}
367
368 const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
369 private:
370 FinallyClause * clone() const override { return new FinallyClause{ *this }; }
371 MUTATE_FRIEND
372};
373
374// Suspend statement
375class SuspendStmt final : public Stmt {
376 public:
377 ptr<CompoundStmt> then;
378 enum Kind { None, Coroutine, Generator } kind = None;
379
380 SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
381 : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
382
383 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
384 private:
385 SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
386 MUTATE_FRIEND
387};
388
389// Base class of WaitFor/WaitUntil statements
390// form: KEYWORD(...) ... timeout(...) ... else ...
391class WaitStmt : public Stmt {
392 public:
393 ptr<Expr> timeout_time;
394 ptr<Stmt> timeout_stmt;
395 ptr<Expr> timeout_cond;
396 ptr<Stmt> else_stmt;
397 ptr<Expr> else_cond;
398
399 WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
400 : Stmt(loc, std::move(labels)) {}
401
402 private:
403 WaitStmt * clone() const override = 0;
404 MUTATE_FRIEND
405};
406
407// Base class for WaitFor/WaitUntil clauses
408// form: when( when_cond ) KEYWORD( target ) stmt
409class WhenClause : public StmtClause {
410 public:
411 ptr<Expr> target;
412 ptr<Stmt> stmt;
413 ptr<Expr> when_cond;
414
415 WhenClause( const CodeLocation & loc )
416 : StmtClause( loc ) {}
417
418 const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
419 private:
420 WhenClause * clone() const override { return new WhenClause{ *this }; }
421 MUTATE_FRIEND
422};
423
424// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
425class WaitForStmt final : public WaitStmt {
426 public:
427 std::vector<ptr<WaitForClause>> clauses;
428
429 WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
430 : WaitStmt(loc, std::move(labels)) {}
431
432 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
433 private:
434 WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
435 MUTATE_FRIEND
436};
437
438// Clause in a waitfor statement: waitfor (..., ...) ...
439class WaitForClause final : public WhenClause {
440 public:
441 std::vector<ptr<Expr>> target_args;
442
443 WaitForClause( const CodeLocation & loc )
444 : WhenClause( loc ) {}
445
446 const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
447 private:
448 WaitForClause * clone() const override { return new WaitForClause{ *this }; }
449 MUTATE_FRIEND
450};
451
452// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
453class WaitUntilStmt final : public WaitStmt {
454 public:
455 // Non-ast node used during compilation to store data needed to generate predicates
456 // and set initial status values for clauses
457 // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
458 struct ClauseNode {
459 enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
460 // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
461
462 ClauseNode * left;
463 ClauseNode * right;
464 WhenClause * leaf; // only set if this node is a leaf (points into vector of clauses)
465
466 bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
467 bool whenState; // used to track if when_cond is toggled on or off for generating init values
468 bool childOfAnd; // true on leaf nodes that are children of AND, false otherwise
469
470 ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
471 : op(op), left(left), right(right), leaf(nullptr),
472 ambiguousWhen(false), whenState(true), childOfAnd(false) {}
473 ClauseNode( Op op, WhenClause * leaf )
474 : op(op), left(nullptr), right(nullptr), leaf(leaf),
475 ambiguousWhen(false), whenState(true), childOfAnd(false) {}
476 ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
477
478 ~ClauseNode() {
479 if ( left ) delete left;
480 if ( right ) delete right;
481 }
482 };
483
484 std::vector<ptr<WhenClause>> clauses;
485 ClauseNode * predicateTree;
486
487 WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
488 : WaitStmt(loc, std::move(labels)) {}
489
490 ~WaitUntilStmt() { delete predicateTree; }
491
492 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
493 private:
494 WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
495 MUTATE_FRIEND
496};
497
498// Any declaration in a (compound) statement.
499class DeclStmt final : public Stmt {
500 public:
501 ptr<Decl> decl;
502
503 DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
504 : Stmt(loc, std::move(labels)), decl(decl) {}
505
506 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
507 private:
508 DeclStmt * clone() const override { return new DeclStmt{ *this }; }
509 MUTATE_FRIEND
510};
511
512// Represents an implicit application of a constructor or destructor.
513class ImplicitCtorDtorStmt final : public Stmt {
514 public:
515 ptr<Stmt> callStmt;
516
517 ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
518 std::vector<Label> && labels = {} )
519 : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
520
521 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
522 private:
523 ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
524 MUTATE_FRIEND
525};
526
527// Mutex Statement
528class MutexStmt final : public Stmt {
529 public:
530 ptr<Stmt> stmt;
531 std::vector<ptr<Expr>> mutexObjs;
532
533 MutexStmt( const CodeLocation & loc, const Stmt * stmt,
534 const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
535 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
536
537 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
538 private:
539 MutexStmt * clone() const override { return new MutexStmt{ *this }; }
540 MUTATE_FRIEND
541};
542
543// Corun Statement
544class CorunStmt final : public Stmt {
545 public:
546 ptr<Stmt> stmt;
547
548 CorunStmt( const CodeLocation & loc, const Stmt * stmt, const std::vector<Label> && labels = {} )
549 : Stmt(loc, std::move(labels)), stmt(stmt) {}
550
551 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
552 private:
553 CorunStmt * clone() const override { return new CorunStmt{ *this }; }
554 MUTATE_FRIEND
555};
556
557// Corun Statement
558class CoforStmt final : public Stmt {
559 public:
560 std::vector<ptr<Stmt>> inits;
561 ptr<Expr> cond;
562 ptr<Expr> inc;
563 ptr<Stmt> body;
564
565 CoforStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
566 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
567 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
568
569 const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
570 private:
571 CoforStmt * clone() const override { return new CoforStmt{ *this }; }
572 MUTATE_FRIEND
573};
574
575} // namespace ast
576
577#undef MUTATE_FRIEND
578
579// Local Variables: //
580// mode: c++ //
581// End: //
Note: See TracBrowser for help on using the repository browser.