Changes in src/AST/Stmt.hpp [6180274:3b0bc16]

File:

• src/AST/Stmt.hpp (modified) (20 diffs)

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 20:06:41 2022
-// Update Count     : 34
+// Last Modified On : Tue Feb  1 17:44:46 2022
+// Update Count     : 24
 //
 
@@ -39 +39 @@
         std::vector<Label> labels;
 
-        Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
                 : ParseNode(loc), labels(std::move(labels)) {}
 
@@ -55 +55 @@
         std::list<ptr<Stmt>> kids;
 
-        CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
+        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
+                                 std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
 
@@ -73 +74 @@
 class NullStmt final : public Stmt {
   public:
-        NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
@@ -87 +88 @@
         ptr<Expr> expr;
 
-        ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
+        ExprStmt( const CodeLocation & loc, const Expr* e, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(e) {}
 
@@ -106 +107 @@
 
         AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
-                         const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
-                         const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
-                         const std::vector<Label> && labels = {})
+                         std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
+                         std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
+                         std::vector<Label> && labels = {})
                 : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
                   output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
@@ -143 +144 @@
 
         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
-                        const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
-                        const std::vector<Label> && labels = {} )
+                        const Stmt * else_ = nullptr, std::vector<ptr<Stmt>> && inits = {},
+                        std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
                   inits(std::move(inits)) {}
@@ -160 +161 @@
         std::vector<ptr<Stmt>> stmts;
 
-        SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-                                const std::vector<Label> && labels = {} )
+        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
+                                std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
@@ -177 +178 @@
         std::vector<ptr<Stmt>> stmts;
 
-        CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-                          const std::vector<Label> && labels = {} )
+        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
+                          std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
@@ -199 +200 @@
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
@@ -221 +222 @@
         ptr<Stmt> else_;
 
-        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
+        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, std::vector<Label> && label = {} )
                 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
 
-        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                         const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
+        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const Stmt * else_, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
 
@@ -246 +247 @@
         Kind kind;
 
-        BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
-        BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
+        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
+                                std::vector<Label> && labels = {} );
+        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
+                                std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
+                  computedTarget(computedTarget), kind(Goto) {}
 
         const char * kindName() const { return kindNames[kind]; }
@@ -265 +269 @@
         ptr<Expr> expr;
 
-        ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
+        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(expr) {}
 
@@ -284 +288 @@
         ExceptionKind kind;
 
-        ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
-                           const Expr * target, const std::vector<Label> && labels = {} )
+        ThrowStmt(
+                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
+                std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
 
@@ -301 +306 @@
         ptr<FinallyStmt> finally;
 
-        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
-                         const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
-                         const std::vector<Label> && labels = {} )
+        TryStmt(
+                const CodeLocation & loc, const CompoundStmt * body,
+                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+                std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
 
@@ -320 +326 @@
         ExceptionKind kind;
 
-        CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                           const Stmt * body, const std::vector<Label> && labels = {} )
+        CatchStmt(
+                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
+                const Stmt * body, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
 
@@ -351 +358 @@
         enum Type { None, Coroutine, Generator } type = None;
 
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), then(then), type(type) {}
 
@@ -389 +396 @@
         OrElse orElse;
 
-        WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
@@ -403 +410 @@
         ptr<Decl> decl;
 
-        DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
+        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), decl(decl) {}
 
@@ -434 +441 @@
 
         MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                           const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
+                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}