source: src/AST/Stmt.hpp @ 89a5a1f

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum
Last change on this file since 89a5a1f was 89a5a1f, checked in by Peter A. Buhr <pabuhr@…>, 2 years ago

formatting, starting adding elsePart to while, do, and for statements

  • Property mode set to 100644
File size: 13.4 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 : Peter A. Buhr
12// Last Modified On : Mon Jan 31 22:38:53 2022
13// Update Count     : 12
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.h"
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, 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// Compound statement: { ... }
53class CompoundStmt final : public Stmt {
54  public:
55        std::list<ptr<Stmt>> kids;
56
57        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
58                                 std::vector<Label>&& labels = {} )
59                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
60
61        CompoundStmt( const CompoundStmt& o );
62        CompoundStmt( CompoundStmt&& o ) = default;
63
64        void push_back( const Stmt * s ) { kids.emplace_back( s ); }
65        void push_front( const Stmt * s ) { kids.emplace_front( s ); }
66
67        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
68  private:
69        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
70        MUTATE_FRIEND
71};
72
73// Empty statment: ;
74class NullStmt final : public Stmt {
75  public:
76        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
77                : Stmt(loc, std::move(labels)) {}
78
79        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
80  private:
81        NullStmt * clone() const override { return new NullStmt{ *this }; }
82        MUTATE_FRIEND
83};
84
85// Expression wrapped by statement
86class ExprStmt final : public Stmt {
87  public:
88        ptr<Expr> expr;
89
90        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
91                : Stmt(loc, std::move(labels)), expr(e) {}
92
93        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
94  private:
95        ExprStmt * clone() const override { return new ExprStmt{ *this }; }
96        MUTATE_FRIEND
97};
98
99// Assembly statement: asm ... ( "..." : ... )
100class AsmStmt final : public Stmt {
101  public:
102        bool isVolatile;
103        ptr<Expr> instruction;
104        std::vector<ptr<Expr>> output, input;
105        std::vector<ptr<ConstantExpr>> clobber;
106        std::vector<Label> gotoLabels;
107
108        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
109                         std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
110                         std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
111                         std::vector<Label> && labels = {})
112                : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
113                  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
114                  gotoLabels(std::move(gotoLabels)) {}
115
116        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
117  private:
118        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
119        MUTATE_FRIEND
120};
121
122// C-preprocessor directive: #...
123class DirectiveStmt final : public Stmt {
124  public:
125        std::string directive;
126
127        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
128                                   std::vector<Label> && labels = {} )
129                : Stmt(loc, std::move(labels)), directive(directive) {}
130
131        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
132  private:
133        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
134        MUTATE_FRIEND
135};
136
137// If statement: if (...) ... else ...
138class IfStmt final : public Stmt {
139  public:
140        ptr<Expr> cond;
141        ptr<Stmt> thenPart;
142        ptr<Stmt> elsePart;
143        std::vector<ptr<Stmt>> inits;
144
145        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
146                        const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
147                        std::vector<Label> && labels = {} )
148                : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
149                  inits(std::move(inits)) {}
150
151        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
152  private:
153        IfStmt * clone() const override { return new IfStmt{ *this }; }
154        MUTATE_FRIEND
155};
156
157// Switch or choose statement: switch (...) { ... }
158class SwitchStmt final : public Stmt {
159  public:
160        ptr<Expr> cond;
161        std::vector<ptr<Stmt>> stmts;
162
163        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
164                                std::vector<Label> && labels = {} )
165                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
166
167        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
168  private:
169        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
170        MUTATE_FRIEND
171};
172
173// Case label: case ...: or default:
174class CaseStmt final : public Stmt {
175  public:
176        // Null for the default label.
177        ptr<Expr> cond;
178        std::vector<ptr<Stmt>> stmts;
179
180        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
181                          std::vector<Label> && labels = {} )
182                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
183
184        bool isDefault() const { return !cond; }
185
186        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
187  private:
188        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
189        MUTATE_FRIEND
190};
191
192// While loop: while (...) ... else ... or do ... while (...) else ...;
193class WhileStmt final : public Stmt {
194  public:
195        ptr<Expr> cond;
196        ptr<Stmt> body;
197        ptr<Stmt> elsePart;
198        std::vector<ptr<Stmt>> inits;
199        bool isDoWhile;
200
201        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
202                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
203                : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)), isDoWhile(isDoWhile) {}
204
205        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
206  private:
207        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
208        MUTATE_FRIEND
209};
210
211// For loop: for (... ; ... ; ...) ... else ...
212class ForStmt final : public Stmt {
213  public:
214        std::vector<ptr<Stmt>> inits;
215        ptr<Expr> cond;
216        ptr<Expr> inc;
217        ptr<Stmt> body;
218        ptr<Stmt> elsePart;
219
220        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
221                         const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
222                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
223
224        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
225  private:
226        ForStmt * clone() const override { return new ForStmt{ *this }; }
227        MUTATE_FRIEND
228};
229
230// Branch control flow statement: goto ... or break or continue or fallthru
231class BranchStmt final : public Stmt {
232  public:
233        enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
234        static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
235
236        const Label originalTarget;
237        Label target;
238        ptr<Expr> computedTarget;
239        Kind kind;
240
241        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
242                                std::vector<Label> && labels = {} );
243        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
244                                std::vector<Label> && labels = {} )
245                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
246                  computedTarget(computedTarget), kind(Goto) {}
247
248        const char * kindName() const { return kindNames[kind]; }
249
250        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
251  private:
252        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
253        MUTATE_FRIEND
254
255        static const char * kindNames[kindEnd];
256};
257
258// Return statement: return ...
259class ReturnStmt final : public Stmt {
260  public:
261        ptr<Expr> expr;
262
263        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
264                : Stmt(loc, std::move(labels)), expr(expr) {}
265
266        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
267  private:
268        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
269        MUTATE_FRIEND
270};
271
272// Kind of exception
273enum ExceptionKind { Terminate, Resume };
274
275// Throw statement: throw ...
276class ThrowStmt final : public Stmt {
277  public:
278        ptr<Expr> expr;
279        ptr<Expr> target;
280        ExceptionKind kind;
281
282        ThrowStmt(
283                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
284                std::vector<Label> && labels = {} )
285                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
286
287        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
288  private:
289        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
290        MUTATE_FRIEND
291};
292
293// Try statement: try { ... } ...
294class TryStmt final : public Stmt {
295  public:
296        ptr<CompoundStmt> body;
297        std::vector<ptr<CatchStmt>> handlers;
298        ptr<FinallyStmt> finally;
299
300        TryStmt(
301                const CodeLocation & loc, const CompoundStmt * body,
302                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
303                std::vector<Label> && labels = {} )
304                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
305
306        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
307  private:
308        TryStmt * clone() const override { return new TryStmt{ *this }; }
309        MUTATE_FRIEND
310};
311
312// Catch clause of try statement
313class CatchStmt final : public Stmt {
314  public:
315        ptr<Decl> decl;
316        ptr<Expr> cond;
317        ptr<Stmt> body;
318        ExceptionKind kind;
319
320        CatchStmt(
321                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
322                const Stmt * body, std::vector<Label> && labels = {} )
323                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
324
325        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
326  private:
327        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
328        MUTATE_FRIEND
329};
330
331// Finally clause of try statement
332class FinallyStmt final : public Stmt {
333  public:
334        ptr<CompoundStmt> body;
335
336        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
337                                 std::vector<Label> && labels = {} )
338                : Stmt(loc, std::move(labels)), body(body) {}
339
340        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
341  private:
342        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
343        MUTATE_FRIEND
344};
345
346// Suspend statement
347class SuspendStmt final : public Stmt {
348  public:
349        ptr<CompoundStmt> then;
350        enum Type { None, Coroutine, Generator } type = None;
351
352        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
353                : Stmt(loc, std::move(labels)), then(then), type(type) {}
354
355        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
356  private:
357        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
358        MUTATE_FRIEND
359};
360
361// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
362class WaitForStmt final : public Stmt {
363  public:
364        struct Target {
365                ptr<Expr> func;
366                std::vector<ptr<Expr>> args;
367        };
368
369        struct Clause {
370                Target target;
371                ptr<Stmt> stmt;
372                ptr<Expr> cond;
373        };
374
375        struct Timeout {
376                ptr<Expr> time;
377                ptr<Stmt> stmt;
378                ptr<Expr> cond;
379        };
380
381        struct OrElse {
382                ptr<Stmt> stmt;
383                ptr<Expr> cond;
384        };
385
386        std::vector<Clause> clauses;
387        Timeout timeout;
388        OrElse orElse;
389
390        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
391                : Stmt(loc, std::move(labels)) {}
392
393        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
394  private:
395        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
396        MUTATE_FRIEND
397};
398
399// Any declaration in a (compound) statement.
400class DeclStmt final : public Stmt {
401  public:
402        ptr<Decl> decl;
403
404        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
405                : Stmt(loc, std::move(labels)), decl(decl) {}
406
407        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
408  private:
409        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
410        MUTATE_FRIEND
411};
412
413// Represents an implicit application of a constructor or destructor.
414class ImplicitCtorDtorStmt final : public Stmt {
415  public:
416        ptr<Stmt> callStmt;
417
418        ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
419                                                  std::vector<Label> && labels = {} )
420                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
421
422        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
423  private:
424        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
425        MUTATE_FRIEND
426};
427
428// Mutex Statement
429class MutexStmt final : public Stmt {
430  public:
431        ptr<Stmt> stmt;
432        std::vector<ptr<Expr>> mutexObjs;
433
434        MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
435                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
436                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
437
438        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
439  private:
440        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
441        MUTATE_FRIEND
442};
443} // namespace ast
444
445#undef MUTATE_FRIEND
446
447// Local Variables: //
448// mode: c++ //
449// End: //
Note: See TracBrowser for help on using the repository browser.