source: src/AST/Stmt.hpp @ fcd65ca

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum
Last change on this file since fcd65ca was 6cebfef, checked in by caparsons <caparson@…>, 3 years ago

added mutex stmt monitor

  • Property mode set to 100644
File size: 13.3 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 : Fri May 17 12:45:00 2019
13// Update Count     : 5
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 {
34
35class Expr;
36
37/// Base statement node
38class Stmt : public ParseNode {
39public:
40        std::vector<Label> labels;
41
42        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
43        : ParseNode(loc), labels(std::move(labels)) {}
44
45        Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
46
47        const Stmt * accept( Visitor & v ) const override = 0;
48private:
49        Stmt * clone() const override = 0;
50        MUTATE_FRIEND
51};
52
53/// Compound statement `{ ... }`
54class CompoundStmt final : public Stmt {
55public:
56        std::list<ptr<Stmt>> kids;
57
58        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
59                std::vector<Label>&& labels = {} )
60        : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
61
62        CompoundStmt( const CompoundStmt& o );
63        CompoundStmt( CompoundStmt&& o ) = default;
64
65        void push_back( const Stmt * s ) { kids.emplace_back( s ); }
66        void push_front( const Stmt * s ) { kids.emplace_front( s ); }
67
68        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
69private:
70        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
71        MUTATE_FRIEND
72};
73
74/// Empty statment `;`
75class NullStmt final : public Stmt {
76public:
77        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
78        : Stmt(loc, std::move(labels)) {}
79
80        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
81private:
82        NullStmt * clone() const override { return new NullStmt{ *this }; }
83        MUTATE_FRIEND
84};
85
86/// Expression wrapped by statement
87class ExprStmt final : public Stmt {
88public:
89        ptr<Expr> expr;
90
91        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
92        : Stmt(loc, std::move(labels)), expr(e) {}
93
94        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
95private:
96        ExprStmt * clone() const override { return new ExprStmt{ *this }; }
97        MUTATE_FRIEND
98};
99
100/// Assembly statement `asm ... ( "..." : ... )`
101class AsmStmt final : public Stmt {
102public:
103        bool isVolatile;
104        ptr<Expr> instruction;
105        std::vector<ptr<Expr>> output, input;
106        std::vector<ptr<ConstantExpr>> clobber;
107        std::vector<Label> gotoLabels;
108
109        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
110                std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
111                std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
112                std::vector<Label> && labels = {})
113        : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
114          output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
115          gotoLabels(std::move(gotoLabels)) {}
116
117        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
118private:
119        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
120        MUTATE_FRIEND
121};
122
123/// C-preprocessor directive `#...`
124class DirectiveStmt final : public Stmt {
125public:
126        std::string directive;
127
128        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
129                std::vector<Label> && labels = {} )
130        : Stmt(loc, std::move(labels)), directive(directive) {}
131
132        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
133private:
134        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
135        MUTATE_FRIEND
136};
137
138/// If conditional statement `if (...) ... else ...`
139class IfStmt final : public Stmt {
140public:
141        ptr<Expr> cond;
142        ptr<Stmt> thenPart;
143        ptr<Stmt> elsePart;
144        std::vector<ptr<Stmt>> inits;
145
146        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
147                const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
148                std::vector<Label> && labels = {} )
149        : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
150          inits(std::move(inits)) {}
151
152        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
153private:
154        IfStmt * clone() const override { return new IfStmt{ *this }; }
155        MUTATE_FRIEND
156};
157
158/// Switch or choose conditional statement `switch (...) { ... }`
159class SwitchStmt final : public Stmt {
160public:
161        ptr<Expr> cond;
162        std::vector<ptr<Stmt>> stmts;
163
164        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
165                std::vector<Label> && labels = {} )
166        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
167
168        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
169private:
170        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
171        MUTATE_FRIEND
172};
173
174/// Case label `case ...:` `default:`
175class CaseStmt final : public Stmt {
176public:
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 ); }
187private:
188        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
189        MUTATE_FRIEND
190};
191
192/// While loop `while (...) ...` `do ... while (...);
193class WhileStmt final : public Stmt {
194public:
195        ptr<Expr> cond;
196        ptr<Stmt> body;
197        std::vector<ptr<Stmt>> inits;
198        bool isDoWhile;
199
200        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
201                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
202        : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
203          isDoWhile(isDoWhile) {}
204
205        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
206private:
207        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
208        MUTATE_FRIEND
209};
210
211/// For loop `for (... ; ... ; ...) ...`
212class ForStmt final : public Stmt {
213public:
214        std::vector<ptr<Stmt>> inits;
215        ptr<Expr> cond;
216        ptr<Expr> inc;
217        ptr<Stmt> body;
218
219        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
220                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
221        : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
222          body(body) {}
223
224        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
225private:
226        ForStmt * clone() const override { return new ForStmt{ *this }; }
227        MUTATE_FRIEND
228};
229
230/// Branch control flow statement `goto ...` `break` `continue` `fallthru`
231class BranchStmt final : public Stmt {
232public:
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 ); }
251private:
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 {
260public:
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 ); }
267private:
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 {
277public:
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 ); }
288private:
289        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
290        MUTATE_FRIEND
291};
292
293/// Try statement `try { ... } ...`
294class TryStmt final : public Stmt {
295public:
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 ); }
307private:
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 {
314public:
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 ); }
326private:
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 {
333public:
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 ); }
341private:
342        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
343        MUTATE_FRIEND
344};
345
346/// Suspend statement
347class SuspendStmt final : public Stmt {
348public:
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 ); }
356private:
357        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
358        MUTATE_FRIEND
359};
360
361/// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
362class WaitForStmt final : public Stmt {
363public:
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 ); }
394private:
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 {
401public:
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 ); }
408private:
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 {
415public:
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 ); }
423private:
424        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
425        MUTATE_FRIEND
426};
427
428/// Mutex Statement
429class MutexStmt final : public Stmt {
430public:
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 ); }
439private:
440        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
441        MUTATE_FRIEND
442};
443
444}
445
446#undef MUTATE_FRIEND
447
448// Local Variables: //
449// tab-width: 4 //
450// mode: c++ //
451// compile-command: "make install" //
452// End: //
Note: See TracBrowser for help on using the repository browser.