Changeset 34c32f0

Timestamp:

Feb 1, 2022, 12:06:24 PM (14 months ago)

Author:

caparsons <caparson@…>

Branches:

enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

ab1a9ea

Parents:

3e5db5b4 (diff), 7b2c8c3c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/concurrency/kernel.cfa (modified) (13 diffs)
• libcfa/src/concurrency/kernel/fwd.hfa (modified) (1 diff)
• src/AST/Stmt.hpp (modified) (12 diffs)
• src/ControlStruct/ExceptTranslateNew.cpp (modified) (3 diffs)
• src/ControlStruct/FixLabels.cpp (modified) (8 diffs)
• src/ControlStruct/FixLabels.hpp (modified) (2 diffs)
• src/ControlStruct/ForExprMutator.h (modified) (2 diffs)
• src/ControlStruct/HoistControlDecls.cpp (modified) (2 diffs)
• src/ControlStruct/HoistControlDecls.hpp (modified) (2 diffs)
• src/ControlStruct/LabelFixer.cc (modified) (2 diffs)
• src/ControlStruct/LabelFixer.h (modified) (2 diffs)
• src/ControlStruct/LabelGenerator.cc (modified) (3 diffs)
• src/ControlStruct/LabelGenerator.h (modified) (2 diffs)
• src/ControlStruct/LabelGeneratorNew.cpp (added)
• src/ControlStruct/LabelGeneratorNew.hpp (added)
• src/ControlStruct/MultiLevelExit.cpp (modified) (28 diffs)
• src/ControlStruct/MultiLevelExit.hpp (modified) (2 diffs)
• src/ControlStruct/module.mk (modified) (2 diffs)
• src/Parser/ParseNode.h (modified) (3 diffs)
• src/Parser/StatementNode.cc (modified) (4 diffs)
• src/Parser/parser.yy (modified) (5 diffs)
• tests/concurrent/preempt.cfa (modified) (4 diffs)
• tools/auto-complete.md (modified) (1 diff)

libcfa/src/concurrency/kernel.cfa

@@ -42 +42 @@
 
 #if !defined(__CFA_NO_STATISTICS__)
-        #define __STATS( ...) __VA_ARGS__
+        #define __STATS_DEF( ...) __VA_ARGS__
 #else
-        #define __STATS( ...)
+        #define __STATS_DEF( ...)
 #endif
 
@@ -122 +122 @@
 static thread$ * __next_thread(cluster * this);
 static thread$ * __next_thread_slow(cluster * this);
+static thread$ * __next_thread_search(cluster * this);
 static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
 static void __run_thread(processor * this, thread$ * dst);
@@ -187 +188 @@
                 MAIN_LOOP:
                 for() {
-                        #define OLD_MAIN 1
-                        #if OLD_MAIN
                         // Check if there is pending io
                         __maybe_io_drain( this );
@@ -196 +195 @@
 
                         if( !readyThread ) {
-                                __tls_stats()->io.flush.idle++;
+                                __IO_STATS__(true, io.flush.idle++; )
                                 __cfa_io_flush( this, 0 );
 
+                                readyThread = __next_thread( this->cltr );
+                        }
+
+                        if( !readyThread ) for(5) {
+                                __IO_STATS__(true, io.flush.idle++; )
+
                                 readyThread = __next_thread_slow( this->cltr );
+
+                                if( readyThread ) break;
+
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -211 +220 @@
 
                                 // Confirm the ready-queue is empty
-                                readyThread = __next_thread_slow( this->cltr );
+                                readyThread = __next_thread_search( this->cltr );
                                 if( readyThread ) {
                                         // A thread was found, cancel the halt
                                         mark_awake(this->cltr->procs, * this);
 
-                                        #if !defined(__CFA_NO_STATISTICS__)
-                                                __tls_stats()->ready.sleep.cancels++;
-                                        #endif
+                                        __STATS__(true, ready.sleep.cancels++; )
 
                                         // continue the mai loop
@@ -245 +252 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __tls_stats()->io.flush.dirty++;
+                                __IO_STATS__(true, io.flush.dirty++; )
                                 __cfa_io_flush( this, 0 );
                         }
-
-                        #else
-                                #warning new kernel loop
-                        SEARCH: {
-                                /* paranoid */ verify( ! __preemption_enabled() );
-
-                                // First, lock the scheduler since we are searching for a thread
-                                ready_schedule_lock();
-
-                                // Try to get the next thread
-                                readyThread = pop_fast( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // If we can't find a thread, might as well flush any outstanding I/O
-                                if(this->io.pending) { __cfa_io_flush( this, 0 ); }
-
-                                // Spin a little on I/O, just in case
-                                for(5) {
-                                        __maybe_io_drain( this );
-                                        readyThread = pop_fast( this->cltr );
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // no luck, try stealing a few times
-                                for(5) {
-                                        if( __maybe_io_drain( this ) ) {
-                                                readyThread = pop_fast( this->cltr );
-                                        } else {
-                                                readyThread = pop_slow( this->cltr );
-                                        }
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // still no luck, search for a thread
-                                readyThread = pop_search( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // Don't block if we are done
-                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
-                                        ready_schedule_unlock();
-                                        break MAIN_LOOP;
-                                }
-
-                                __STATS( __tls_stats()->ready.sleep.halts++; )
-
-                                // Push self to idle stack
-                                ready_schedule_unlock();
-                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
-                                ready_schedule_lock();
-
-                                // Confirm the ready-queue is empty
-                                __maybe_io_drain( this );
-                                readyThread = pop_search( this->cltr );
-                                ready_schedule_unlock();
-
-                                if( readyThread ) {
-                                        // A thread was found, cancel the halt
-                                        mark_awake(this->cltr->procs, * this);
-
-                                        __STATS( __tls_stats()->ready.sleep.cancels++; )
-
-                                        // continue the main loop
-                                        break SEARCH;
-                                }
-
-                                __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
-                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
-
-                                {
-                                        eventfd_t val;
-                                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
-                                        if(ret < 0) {
-                                                switch((int)errno) {
-                                                case EAGAIN:
-                                                #if EAGAIN != EWOULDBLOCK
-                                                        case EWOULDBLOCK:
-                                                #endif
-                                                case EINTR:
-                                                        // No need to do anything special here, just assume it's a legitimate wake-up
-                                                        break;
-                                                default:
-                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
-                                                }
-                                        }
-                                }
-
-                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
-
-                                // We were woken up, remove self from idle
-                                mark_awake(this->cltr->procs, * this);
-
-                                // DON'T just proceed, start looking again
-                                continue MAIN_LOOP;
-                        }
-
-                RUN_THREAD:
-                        /* paranoid */ verify( ! __preemption_enabled() );
-                        /* paranoid */ verify( readyThread );
-
-                        // Reset io dirty bit
-                        this->io.dirty = false;
-
-                        // We found a thread run it
-                        __run_thread(this, readyThread);
-
-                        // Are we done?
-                        if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-                        if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, 0 );
-                        }
-
-                        ready_schedule_lock();
-                        __maybe_io_drain( this );
-                        ready_schedule_unlock();
-                        #endif
                 }
 
@@ -474 +365 @@
                                 break RUNNING;
                         case TICKET_UNBLOCK:
-                                #if !defined(__CFA_NO_STATISTICS__)
-                                        __tls_stats()->ready.threads.threads++;
-                                #endif
+                                __STATS__(true, ready.threads.threads++; )
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
@@ -491 +380 @@
         __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
 
-        #if !defined(__CFA_NO_STATISTICS__)
-                __tls_stats()->ready.threads.threads--;
-        #endif
+        __STATS__(true, ready.threads.threads--; )
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -504 +391 @@
         thread$ * thrd_src = kernelTLS().this_thread;
 
-        __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
+        __STATS_DEF( thrd_src->last_proc = kernelTLS().this_processor; )
 
         // Run the thread on this processor
@@ -556 +443 @@
         // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
         struct cluster * cl = thrd->curr_cluster;
-        __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
+        __STATS_DEF(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
 
         // push the thread to the cluster ready-queue
@@ -607 +494 @@
 
         ready_schedule_lock();
-                thread$ * thrd;
-                for(25) {
-                        thrd = pop_slow( this );
-                        if(thrd) goto RET;
-                }
-                thrd = pop_search( this );
-
-                RET:
+                thread$ * thrd = pop_slow( this );
+        ready_schedule_unlock();
+
+        /* paranoid */ verify( ! __preemption_enabled() );
+        return thrd;
+}
+
+// KERNEL ONLY
+static inline thread$ * __next_thread_search(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+
+        ready_schedule_lock();
+                thread$ * thrd = pop_search( this );
         ready_schedule_unlock();
 
@@ -856 +748 @@
 
 static bool mark_idle(__cluster_proc_list & this, processor & proc) {
-        #if !defined(__CFA_NO_STATISTICS__)
-                __tls_stats()->ready.sleep.halts++;
-        #endif
+        __STATS__(true, ready.sleep.halts++; )
 
         proc.idle_wctx.fd = 0;
@@ -951 +841 @@
                 unsigned tail = *ctx->cq.tail;
                 if(head == tail) return false;
-                #if OLD_MAIN
-                        ready_schedule_lock();
-                        ret = __cfa_io_drain( proc );
-                        ready_schedule_unlock();
-                #else
-                        ret = __cfa_io_drain( proc );
-                #endif
+                ready_schedule_lock();
+                ret = __cfa_io_drain( proc );
+                ready_schedule_unlock();
         #endif
         return ret;

libcfa/src/concurrency/kernel/fwd.hfa

@@ -396 +396 @@
                                 if( !(in_kernel) ) enable_interrupts(); \
                         }
+                        #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                                #define __IO_STATS__(in_kernel, ...) { \
+                                        if( !(in_kernel) ) disable_interrupts(); \
+                                        with( *__tls_stats() ) { \
+                                                __VA_ARGS__ \
+                                        } \
+                                        if( !(in_kernel) ) enable_interrupts(); \
+                                }
+                        #else
+                                #define __IO_STATS__(in_kernel, ...)
+                        #endif
                 #else
                         #define __STATS__(in_kernel, ...)
+                        #define __IO_STATS__(in_kernel, ...)
                 #endif
         }

src/AST/Stmt.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:45:00 2019
-// Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:38:53 2022
+// Update Count     : 12
 //
 
@@ -17 +17 @@
 
 #include <list>
-#include <utility>                // for move
+#include <utility>                                                                              // for move
 #include <vector>
 
 #include "Label.hpp"
-#include "Node.hpp"               // for node, ptr
+#include "Node.hpp"                                                                             // for node, ptr
 #include "ParseNode.hpp"
 #include "Visitor.hpp"
@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND \
+#define MUTATE_FRIEND                                                                                                   \
     template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
-
 class Expr;
 
-/// Base statement node
+// Base statement node
 class Stmt : public ParseNode {
-public:
+  public:
         std::vector<Label> labels;
 
         Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : ParseNode(loc), labels(std::move(labels)) {}
+                : ParseNode(loc), labels(std::move(labels)) {}
 
         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
 
         const Stmt * accept( Visitor & v ) const override = 0;
-private:
+  private:
         Stmt * clone() const override = 0;
         MUTATE_FRIEND
 };
 
-/// Compound statement `{ ... }`
+// Compound statement: { ... }
 class CompoundStmt final : public Stmt {
-public:
+  public:
         std::list<ptr<Stmt>> kids;
 
         CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
-                std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
+                                 std::vector<Label>&& labels = {} )
+                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
 
         CompoundStmt( const CompoundStmt& o );
@@ -67 +66 @@
 
         const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Empty statment `;`
+// Empty statment: ;
 class NullStmt final : public Stmt {
-public:
+  public:
         NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
+                : Stmt(loc, std::move(labels)) {}
 
         const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         NullStmt * clone() const override { return new NullStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Expression wrapped by statement
+// Expression wrapped by statement
 class ExprStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
         ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), expr(e) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(e) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ExprStmt * clone() const override { return new ExprStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Assembly statement `asm ... ( "..." : ... )`
+// Assembly statement: asm ... ( "..." : ... )
 class AsmStmt final : public Stmt {
-public:
+  public:
         bool isVolatile;
         ptr<Expr> instruction;
@@ -108 +107 @@
 
         AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
-                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)),
-          gotoLabels(std::move(gotoLabels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                         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)),
+                  gotoLabels(std::move(gotoLabels)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         AsmStmt * clone() const override { return new AsmStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// C-preprocessor directive `#...`
+// C-preprocessor directive: #...
 class DirectiveStmt final : public Stmt {
-public:
+  public:
         std::string directive;
 
         DirectiveStmt( const CodeLocation & loc, const std::string & directive,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), directive(directive) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                   std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), directive(directive) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// If conditional statement `if (...) ... else ...`
+// If statement: if (...) ... else ...
 class IfStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         ptr<Stmt> thenPart;
@@ -145 +144 @@
 
         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
-                const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
-          inits(std::move(inits)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                        const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
+                        std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
+                  inits(std::move(inits)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         IfStmt * clone() const override { return new IfStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Switch or choose conditional statement `switch (...) { ... }`
+// Switch or choose statement: switch (...) { ... }
 class SwitchStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
         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)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Case label `case ...:` `default:`
+// Case label: case ...: or default:
 class CaseStmt final : public Stmt {
-public:
-        /// Null for the default label.
+  public:
+        // Null for the default label.
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
         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)) {}
+                          std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() const { return !cond; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CaseStmt * clone() const override { return new CaseStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// While loop `while (...) ...` `do ... while (...);
+// While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         ptr<Stmt> body;
+        ptr<Stmt> elsePart;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
 
         WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
-          isDoWhile(isDoWhile) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)), isDoWhile(isDoWhile) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         WhileStmt * clone() const override { return new WhileStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// For loop `for (... ; ... ; ...) ...`
+// For loop: for (... ; ... ; ...) ... else ...
 class ForStmt final : public Stmt {
-public:
+  public:
         std::vector<ptr<Stmt>> inits;
         ptr<Expr> cond;
         ptr<Expr> inc;
         ptr<Stmt> body;
+        ptr<Stmt> elsePart;
 
         ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
-          body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                         const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ForStmt * clone() const override { return new ForStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Branch control flow statement `goto ...` `break` `continue` `fallthru`
+// Branch control flow statement: goto ... or break or continue or fallthru
 class BranchStmt final : public Stmt {
-public:
+  public:
         enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
         static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
@@ -241 +240 @@
 
         BranchStmt( const CodeLocation & loc, Kind kind, Label target,
-                std::vector<Label> && labels = {} );
+                                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) {}
+                                std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
+                  computedTarget(computedTarget), kind(Goto) {}
 
         const char * kindName() const { return kindNames[kind]; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         BranchStmt * clone() const override { return new BranchStmt{ *this }; }
         MUTATE_FRIEND
@@ -257 +256 @@
 };
 
-/// Return statement `return ...`
+// Return statement: return ...
 class ReturnStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
         ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), expr(expr) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(expr) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Kind of exception
+// Kind of exception
 enum ExceptionKind { Terminate, Resume };
 
-/// Throw statement `throw ...`
+// Throw statement: throw ...
 class ThrowStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
         ptr<Expr> target;
@@ -284 +283 @@
                 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) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Try statement `try { ... } ...`
+// Try statement: try { ... } ...
 class TryStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
         std::vector<ptr<CatchStmt>> handlers;
@@ -303 +302 @@
                 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) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         TryStmt * clone() const override { return new TryStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Catch clause of try statement
+// Catch clause of try statement
 class CatchStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
         ptr<Expr> cond;
@@ -322 +321 @@
                 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) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         CatchStmt * clone() const override { return new CatchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Finally clause of try statement
+// Finally clause of try statement
 class FinallyStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
 
         FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                 std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Suspend statement
+// Suspend statement
 class SuspendStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> then;
         enum Type { None, Coroutine, Generator } type = None;
 
         SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), then(then), type(type) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
 class WaitForStmt final : public Stmt {
-public:
+  public:
         struct Target {
                 ptr<Expr> func;
@@ -390 +389 @@
 
         WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Any declaration in a (compound) statement.
+// Any declaration in a (compound) statement.
 class DeclStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
 
         DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), decl(decl) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), decl(decl) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DeclStmt * clone() const override { return new DeclStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Represents an implicit application of a constructor or destructor.
+// Represents an implicit application of a constructor or destructor.
 class ImplicitCtorDtorStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                                  std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Mutex Statement
+// Mutex Statement
 class MutexStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> stmt;
         std::vector<ptr<Expr>> mutexObjs;
 
         MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         MutexStmt * clone() const override { return new MutexStmt{ *this }; }
         MUTATE_FRIEND
 };
-
-}
+} // namespace ast
 
 #undef MUTATE_FRIEND
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/ControlStruct/ExceptTranslateNew.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  8 11:53:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 16:50:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 18:49:58 2022
+// Update Count     : 1
 //
 
@@ -22 +22 @@
 
 namespace ControlStruct {
-
-namespace {
 
 class TranslateThrowsCore : public ast::WithGuards {
@@ -128 +126 @@
 }
 
-} // namespace
-
 void translateThrows( ast::TranslationUnit & transUnit ) {
         ast::Pass<TranslateThrowsCore>::run( transUnit );

src/ControlStruct/FixLabels.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:39:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:19:17 2022
+// Update Count     : 9
 //
 
@@ -20 +20 @@
 #include "AST/Stmt.hpp"
 #include "ControlStruct/MultiLevelExit.hpp"
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
-class FixLabelsCore final : public ast::WithGuards {
+class FixLabelsCore final : public WithGuards {
         LabelToStmt labelTable;
-public:
+  public:
         FixLabelsCore() : labelTable() {}
 
-        void previsit( const ast::FunctionDecl * );
-        const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
-        void previsit( const ast::Stmt * );
-        void previsit( const ast::BranchStmt * );
-        void previsit( const ast::LabelAddressExpr * );
+        void previsit( const FunctionDecl * );
+        const FunctionDecl * postvisit( const FunctionDecl * );
+        void previsit( const Stmt * );
+        void previsit( const BranchStmt * );
+        void previsit( const LabelAddressExpr * );
 
-        void setLabelsDef( const std::vector<ast::Label> &, const ast::Stmt * );
-        void setLabelsUsage( const ast::Label & );
+        void setLabelsDef( const std::vector<Label> &, const Stmt * );
+        void setLabelsUsage( const Label & );
 };
 
-void FixLabelsCore::previsit( const ast::FunctionDecl * ) {
+void FixLabelsCore::previsit( const FunctionDecl * ) {
         GuardValue( labelTable ).clear();
 }
 
-const ast::FunctionDecl * FixLabelsCore::postvisit(
-                const ast::FunctionDecl * decl ) {
+const FunctionDecl * FixLabelsCore::postvisit(
+        const FunctionDecl * decl ) {
         if ( nullptr == decl->stmts ) return decl;
         for ( auto kvp : labelTable ) {
                 if ( nullptr == kvp.second ) {
                         SemanticError( kvp.first.location,
-                                "Use of undefined label: " + kvp.first.name );
+                                                   "Use of undefined label: " + kvp.first.name );
                 }
         }
-        return ast::mutate_field( decl, &ast::FunctionDecl::stmts,
-                multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
+        return mutate_field( decl, &FunctionDecl::stmts,
+                                                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
 }
 
-void FixLabelsCore::previsit( const ast::Stmt * stmt ) {
+void FixLabelsCore::previsit( const Stmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -63 +61 @@
 }
 
-void FixLabelsCore::previsit( const ast::BranchStmt * stmt ) {
+void FixLabelsCore::previsit( const BranchStmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -72 +70 @@
 }
 
-void FixLabelsCore::previsit( const ast::LabelAddressExpr * expr ) {
+void FixLabelsCore::previsit( const LabelAddressExpr * expr ) {
         assert( !expr->arg.empty() );
         setLabelsUsage( expr->arg );
@@ -78 +76 @@
 
 void FixLabelsCore::setLabelsDef(
-                const std::vector<ast::Label> & labels, const ast::Stmt * stmt ) {
+        const std::vector<Label> & labels, const Stmt * stmt ) {
         assert( !labels.empty() );
         assert( stmt );
@@ -89 +87 @@
                         // Duplicate definition, this is an error.
                         SemanticError( label.location,
-                                "Duplicate definition of label: " + label.name );
+                                                   "Duplicate definition of label: " + label.name );
                 } else {
                         // Perviously used, but not defined until now.
@@ -98 +96 @@
 
 // Label was used, if it is new add it to the table.
-void FixLabelsCore::setLabelsUsage( const ast::Label & label ) {
+void FixLabelsCore::setLabelsUsage( const Label & label ) {
         if ( labelTable.find( label ) == labelTable.end() ) {
                 labelTable[ label ] = nullptr;
@@ -104 +102 @@
 }
 
-} // namespace
-
-void fixLabels( ast::TranslationUnit & translationUnit ) {
-        ast::Pass<FixLabelsCore>::run( translationUnit );
+void fixLabels( TranslationUnit & translationUnit ) {
+        Pass<FixLabelsCore>::run( translationUnit );
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/FixLabels.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:36:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  1 09:40:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:18:43 2022
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 
 namespace ast {
-        class TranslationUnit;
+class TranslationUnit;
 }
 
 namespace ControlStruct {
-
-/// normalizes label definitions and generates multi-level exit labels
+// normalizes label definitions and generates multi-level exit labels
 void fixLabels( ast::TranslationUnit & translationUnit );
-
 }
 

src/ControlStruct/ForExprMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 15:32:48 2017
-// Update Count     : 5
+// Last Modified On : Sun Jan 30 09:14:46 2022
+// Update Count     : 6
 //
 
@@ -24 +24 @@
         class ForExprMutator {
           public:
-                Statement *postmutate( IfStmt * );
-                Statement *postmutate( ForStmt * );
-                Statement *postmutate( WhileStmt * );
+                Statement * postmutate( IfStmt * );
+                Statement * postmutate( ForStmt * );
+                Statement * postmutate( WhileStmt * );
         };
 } // namespace ControlStruct

src/ControlStruct/HoistControlDecls.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Fri Dec  3 15:34:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Dec  3 15:34:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 18:52:35 2022
+// Update Count     : 23
 //
 
@@ -19 +19 @@
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
+using namespace ast;
 
 namespace ControlStruct {
 
-namespace {
+template<typename StmtT>
+const Stmt * hoist( const StmtT * stmt ) {
+        // If no hoisting is needed, then make no changes.
 
-template<typename StmtT>
-const ast::Stmt * hoist( const StmtT * stmt ) {
-        // If no hoisting is needed, then make no changes.
-        if ( 0 == stmt->inits.size() ) {
+        if ( stmt->inits.size() == 0 ) {                                        // no declarations ?
+                // if ( /* no conditional declarations */ ...  ) ...
                 return stmt;
-        }
+        } // if
 
-        // Put initializers and the old statement in the compound statement.
-        ast::CompoundStmt * block = new ast::CompoundStmt( stmt->location );
-        StmtT * mutStmt = ast::mutate( stmt );
-        for ( const ast::Stmt * next : mutStmt->inits ) {
+        // Put hoist declarations and modified statement in a compound statement.
+
+        CompoundStmt * block = new CompoundStmt( stmt->location ); // create empty compound statement
+        //    {
+        //    }
+
+        for ( const Stmt * next : stmt->inits ) {                       // link conditional declarations into compound
                 block->kids.push_back( next );
         }
-        mutStmt->inits.clear();
-        block->kids.push_back( mutStmt );
+        //    if ( int x = f(), y = g(); ... ) ...
+        // link declarations into compound statement
+        //    {
+        //         int x = f();
+        //         int y = g();
+        //    }
+
+        StmtT * mutStmt = mutate( stmt );                                       // create mutate handle to change statement
+        mutStmt->inits.clear();                                                         // remove declarations
+        //    if ( ... ) ...
+
+        block->kids.push_back( mutStmt );                                       // link modified statement into compound
+        //    {
+        //        int x = f();
+        //        int y = g();
+        //        if ( ... ) ...
+        //    }
         return block;
 }
 
-struct HoistControlCore {
-        const ast::Stmt * postvisit( const ast::IfStmt * stmt ) {
-                return hoist<ast::IfStmt>( stmt );
+struct hoistControlDeclsCore {
+        // Statements with declarations in conditional.
+        const Stmt * postvisit( const IfStmt * stmt ) {
+                return hoist<IfStmt>( stmt );
         }
-        const ast::Stmt * postvisit( const ast::ForStmt * stmt ) {
-                return hoist<ast::ForStmt>( stmt );
+        const Stmt * postvisit( const ForStmt * stmt ) {
+                return hoist<ForStmt>( stmt );
         }
-        const ast::Stmt * postvisit( const ast::WhileStmt * stmt ) {
-                return hoist<ast::WhileStmt>( stmt );
+        const Stmt * postvisit( const WhileStmt * stmt ) {
+                return hoist<WhileStmt>( stmt );
         }
 };
 
-} // namespace
-
-/// Hoist initialization out of for statements.
-void hoistControlDecls( ast::TranslationUnit & translationUnit ) {
-        ast::Pass<HoistControlCore>::run( translationUnit );
+// Hoist initialization out of for statements.
+void hoistControlDecls( TranslationUnit & translationUnit ) {
+        Pass<hoistControlDeclsCore>::run( translationUnit );
 }
 

src/ControlStruct/HoistControlDecls.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Fri Dec  3 15:31:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Dec  3 15:31:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:25:07 2022
+// Update Count     : 3
 //
 
@@ -17 +17 @@
 
 namespace ast {
-        class TranslationUnit;
+class TranslationUnit;
 }
 
 namespace ControlStruct {
-
-/// Hoist initialization out of control flow statements.
+// Hoist declarations out of control flow statements into compound statement.
 void hoistControlDecls( ast::TranslationUnit & translationUnit );
-
 } // namespace ControlStruct
 

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jan 21 10:32:00 2020
-// Update Count     : 160
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:28:31 2022
+// Update Count     : 161
 //
 
@@ -27 +27 @@
 
 namespace ControlStruct {
-        bool LabelFixer::Entry::insideLoop() {
-                return ( dynamic_cast< ForStmt * > ( definition ) ||
-                        dynamic_cast< WhileStmt * > ( definition )  );
+bool LabelFixer::Entry::insideLoop() {
+        return ( dynamic_cast< ForStmt * > ( definition ) ||
+                dynamic_cast< WhileStmt * > ( definition )  );
+}
+
+LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
+        if ( generator == 0 )
+                generator = LabelGenerator::getGenerator();
+}
+
+void LabelFixer::previsit( FunctionDecl * ) {
+        // need to go into a nested function in a fresh state
+        GuardValue( labelTable );
+        labelTable.clear();
+}
+
+void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
+        PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+        // We start in the body so we can stop when we hit another FunctionDecl.
+        maybeMutate( functionDecl->statements, mlem );
+}
+
+// prune to at most one label definition for each statement
+void LabelFixer::previsit( Statement * stmt ) {
+        std::list< Label > &labels = stmt->get_labels();
+
+        if ( ! labels.empty() ) {
+                // only remember one label for each statement
+                Label current = setLabelsDef( labels, stmt );
+        } // if
+}
+
+void LabelFixer::previsit( BranchStmt * branchStmt ) {
+        previsit( ( Statement *)branchStmt );
+
+        // for labeled branches, add an entry to the label table
+        Label target = branchStmt->get_target();
+        if ( target != "" ) {
+                setLabelsUsg( target, branchStmt );
+        }
+}
+
+void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
+        Label & target = addrExpr->arg;
+        assert( target != "" );
+        setLabelsUsg( target, addrExpr );
+}
+
+
+// Sets the definition of the labelTable entry to be the provided statement for every label in
+// the list parameter. Happens for every kind of statement.
+Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
+        assert( definition != 0 );
+        assert( llabel.size() > 0 );
+
+        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
+                Label & l = *i;
+                l.set_statement( definition ); // attach statement to the label to be used later
+                if ( labelTable.find( l ) == labelTable.end() ) {
+                        // All labels on this statement need to use the same entry,
+                        // so this should only be created once.
+                        // undefined and unused until now, add an entry
+                        labelTable[ l ] = new Entry( definition );
+                } else if ( labelTable[ l ]->defined() ) {
+                        // defined twice, error
+                        SemanticError( l.get_statement()->location,
+                                "Duplicate definition of label: " + l.get_name() );
+                } else {
+                        // used previously, but undefined until now -> link with this entry
+                        // Question: Is changing objects important?
+                        delete labelTable[ l ];
+                        labelTable[ l ] = new Entry( definition );
+                } // if
+        } // for
+
+        // Produce one of the labels attached to this statement to be temporarily used as the
+        // canonical label.
+        return labelTable[ llabel.front() ]->get_label();
+}
+
+// A label was used, add it to the table if it isn't already there
+template< typename UsageNode >
+void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
+        assert( use != 0 );
+
+        // add label with an unknown origin
+        if ( labelTable.find( orgValue ) == labelTable.end() ) {
+                labelTable[ orgValue ] = new Entry( 0 );
+        }
+}
+
+// Builds a table that maps a label to its defining statement.
+std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
+        for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
+                if ( ! i->second->defined() ) {
+                        SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
+                }
+                (*ret)[ i->first ] = i->second->get_definition();
         }
 
-        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
-                if ( generator == 0 )
-                        generator = LabelGenerator::getGenerator();
-        }
-
-        void LabelFixer::previsit( FunctionDecl * ) {
-                // need to go into a nested function in a fresh state
-                GuardValue( labelTable );
-                labelTable.clear();
-        }
-
-        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
-                // We start in the body so we can stop when we hit another FunctionDecl.
-                maybeMutate( functionDecl->statements, mlem );
-        }
-
-        // prune to at most one label definition for each statement
-        void LabelFixer::previsit( Statement * stmt ) {
-                std::list< Label > &labels = stmt->get_labels();
-
-                if ( ! labels.empty() ) {
-                        // only remember one label for each statement
-                        Label current = setLabelsDef( labels, stmt );
-                } // if
-        }
-
-        void LabelFixer::previsit( BranchStmt * branchStmt ) {
-                previsit( ( Statement *)branchStmt );
-
-                // for labeled branches, add an entry to the label table
-                Label target = branchStmt->get_target();
-                if ( target != "" ) {
-                        setLabelsUsg( target, branchStmt );
-                }
-        }
-
-        void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
-                Label & target = addrExpr->arg;
-                assert( target != "" );
-                setLabelsUsg( target, addrExpr );
-        }
-
-
-        // Sets the definition of the labelTable entry to be the provided statement for every label in
-        // the list parameter. Happens for every kind of statement.
-        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
-                assert( definition != 0 );
-                assert( llabel.size() > 0 );
-
-                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
-                        Label & l = *i;
-                        l.set_statement( definition ); // attach statement to the label to be used later
-                        if ( labelTable.find( l ) == labelTable.end() ) {
-                                // All labels on this statement need to use the same entry,
-                                // so this should only be created once.
-                                // undefined and unused until now, add an entry
-                                labelTable[ l ] = new Entry( definition );
-                        } else if ( labelTable[ l ]->defined() ) {
-                                // defined twice, error
-                                SemanticError( l.get_statement()->location,
-                                        "Duplicate definition of label: " + l.get_name() );
-                        } else {
-                                // used previously, but undefined until now -> link with this entry
-                                // Question: Is changing objects important?
-                                delete labelTable[ l ];
-                                labelTable[ l ] = new Entry( definition );
-                        } // if
-                } // for
-
-                // Produce one of the labels attached to this statement to be temporarily used as the
-                // canonical label.
-                return labelTable[ llabel.front() ]->get_label();
-        }
-
-        // A label was used, add it to the table if it isn't already there
-        template< typename UsageNode >
-        void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
-                assert( use != 0 );
-
-                // add label with an unknown origin
-                if ( labelTable.find( orgValue ) == labelTable.end() ) {
-                        labelTable[ orgValue ] = new Entry( 0 );
-                }
-        }
-
-        // Builds a table that maps a label to its defining statement.
-        std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
-                std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
-                for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
-                        if ( ! i->second->defined() ) {
-                                SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
-                        }
-                        (*ret)[ i->first ] = i->second->get_definition();
-                }
-
-                return ret;
-        }
+        return ret;
+}
 }  // namespace ControlStruct
 

src/ControlStruct/LabelFixer.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:17:24 2017
-// Update Count     : 34
+// Last Modified On : Mon Jan 31 22:28:04 2022
+// Update Count     : 35
 //
 
@@ -26 +26 @@
 
 namespace ControlStruct {
-        /// normalizes label definitions and generates multi-level exit labels
-        class LabelGenerator;
+// normalizes label definitions and generates multi-level exit labels
+class LabelGenerator;
 
-        class LabelFixer final : public WithGuards {
-          public:
-                LabelFixer( LabelGenerator *gen = 0 );
+class LabelFixer final : public WithGuards {
+  public:
+        LabelFixer( LabelGenerator *gen = 0 );
 
-                std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
+        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
 
-                // Declarations
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
+        // Declarations
+        void previsit( FunctionDecl *functionDecl );
+        void postvisit( FunctionDecl *functionDecl );
 
-                // Statements
-                void previsit( Statement *stmt );
-                void previsit( BranchStmt *branchStmt );
+        // Statements
+        void previsit( Statement *stmt );
+        void previsit( BranchStmt *branchStmt );
 
-                // Expressions
-                void previsit( LabelAddressExpr *addrExpr );
+        // Expressions
+        void previsit( LabelAddressExpr *addrExpr );
 
-                Label setLabelsDef( std::list< Label > &, Statement *definition );
-                template< typename UsageNode >
-                void setLabelsUsg( Label, UsageNode *usage = 0 );
+        Label setLabelsDef( std::list< Label > &, Statement *definition );
+        template< typename UsageNode >
+        void setLabelsUsg( Label, UsageNode *usage = 0 );
+
+  private:
+        class Entry {
+                public:
+                Entry( Statement *to ) : definition( to ) {}
+                bool defined() { return ( definition != 0 ); }
+                bool insideLoop();
+
+                Label get_label() const { return label; }
+                void set_label( Label lab ) { label = lab; }
+
+                Statement *get_definition() const { return definition; }
+                void set_definition( Statement *def ) { definition = def; }
 
           private:
-                class Entry {
-                        public:
-                        Entry( Statement *to ) : definition( to ) {}
-                        bool defined() { return ( definition != 0 ); }
-                        bool insideLoop();
+                Label label;
+                Statement *definition;
+        };
 
-                        Label get_label() const { return label; }
-                        void set_label( Label lab ) { label = lab; }
-
-                        Statement *get_definition() const { return definition; }
-                        void set_definition( Statement *def ) { definition = def; }
-
-                  private:
-                        Label label;
-                        Statement *definition;
-                };
-
-                std::map < Label, Entry *> labelTable;
-                LabelGenerator *generator;
-        };
+        std::map < Label, Entry *> labelTable;
+        LabelGenerator *generator;
+};
 } // namespace ControlStruct
 

src/ControlStruct/LabelGenerator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:18:00 2021
-// Update Count     : 17
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:26 2022
+// Update Count     : 28
 //
 
@@ -17 +17 @@
 #include <sstream>              // for ostringstream
 #include <list>                 // for list
+using namespace std;
 
 #include "LabelGenerator.h"
 
-#include "AST/Attribute.hpp"
-#include "AST/Label.hpp"
-#include "AST/Stmt.hpp"
 #include "SynTree/Attribute.h"  // for Attribute
 #include "SynTree/Label.h"      // for Label, operator<<
@@ -28 +26 @@
 
 namespace ControlStruct {
-
 int LabelGenerator::current = 0;
 LabelGenerator * LabelGenerator::labelGenerator = nullptr;
 
-        LabelGenerator * LabelGenerator::getGenerator() {
-                if ( LabelGenerator::labelGenerator == 0 )
-                        LabelGenerator::labelGenerator = new LabelGenerator();
-                return labelGenerator;
-        }
-
-        Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
-                std::ostringstream os;
-                os << "__L" << current++ << "__" << suffix;
-                if ( stmt && ! stmt->get_labels().empty() ) {
-                        os << "_" << stmt->get_labels().front() << "__";
-                } // if
-                std::string ret = os.str();
-                Label l( ret );
-                l.get_attributes().push_back( new Attribute("unused") );
-                return l;
-        }
-
-ast::Label LabelGenerator::newLabel(
-                const std::string & suffix, const ast::Stmt * stmt ) {
-        assert( stmt );
-
-        std::ostringstream os;
-        os << "__L" << current++ << "__" << suffix;
-        if ( stmt && !stmt->labels.empty() ) {
-                os << "_" << stmt->labels.front() << "__";
-        }
-        ast::Label ret_label( stmt->location, os.str() );
-        ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
-        return ret_label;
+LabelGenerator * LabelGenerator::getGenerator() {
+        if ( LabelGenerator::labelGenerator == 0 )
+                LabelGenerator::labelGenerator = new LabelGenerator();
+        return labelGenerator;
 }
 
+Label LabelGenerator::newLabel( string suffix, Statement * stmt ) {
+        ostringstream os;
+        os << "__L_OLD" << current++ << "__" << suffix;
+        if ( stmt && ! stmt->get_labels().empty() ) {
+                os << "_" << stmt->get_labels().front() << "__";
+        } // if
+        string ret = os.str();
+        Label l( ret );
+        l.get_attributes().push_back( new Attribute( "unused" ) );
+        return l;
+}
 } // namespace ControlStruct
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/ControlStruct/LabelGenerator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:16:00 2021
-// Update Count     : 8
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:10 2022
+// Update Count     : 16
 //
 
@@ -21 +21 @@
 
 class Statement;
+
 namespace ast {
-        class Stmt;
-        class Label;
+class Stmt;
+class Label;
 }
 
 namespace ControlStruct {
-
 class LabelGenerator {
         static int current;
         static LabelGenerator *labelGenerator;
-protected:
+  protected:
         LabelGenerator() {}
-public:
+  public:
         static LabelGenerator *getGenerator();
         static Label newLabel(std::string suffix, Statement * stmt = nullptr);
-        static ast::Label newLabel( const std::string&, const ast::Stmt * );
-        static void reset() { current = 0; }
-        static void rewind() { current--; }
 };
-
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:48:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:56:00 2021
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:35:08 2022
+// Update Count     : 28
 //
 
@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
-#include "ControlStruct/LabelGenerator.h"
+#include "LabelGeneratorNew.hpp"
 
 #include <set>
+using namespace std;
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
 class Entry {
-public:
-        const ast::Stmt * stmt;
-private:
+  public:
+        const Stmt * stmt;
+  private:
         // Organized like a manual ADT. Avoids creating a bunch of dead data.
         struct Target {
-                ast::Label label;
+                Label label;
                 bool used = false;
-                Target( const ast::Label & label ) : label( label ) {}
+                Target( const Label & label ) : label( label ) {}
                 Target() : label( CodeLocation() ) {}
         };
@@ -41 +40 @@
 
         enum Kind {
-                ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
+                ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
         } kind;
 
         bool fallDefaultValid = true;
 
-        static ast::Label & useTarget( Target & target ) {
+        static Label & useTarget( Target & target ) {
                 target.used = true;
                 return target.label;
         }
 
-public:
-        Entry( const ast::ForStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmt ) {}
-        Entry( const ast::WhileStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmt ) {}
-        Entry( const ast::CompoundStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmt ) {}
-        Entry( const ast::IfStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmt ) {}
-        Entry( const ast::CaseStmt *stmt, ast::Label fallExit ) :
-                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmt ) {}
-        Entry( const ast::SwitchStmt *stmt, ast::Label breakExit, ast::Label fallDefaultExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmt ) {}
-        Entry( const ast::TryStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmt ) {}
-
-        bool isContTarget() const { return kind <= WhileStmt; }
-        bool isBreakTarget() const { return CaseStmt != kind; }
-        bool isFallTarget() const { return CaseStmt == kind; }
-        bool isFallDefaultTarget() const { return SwitchStmt == kind; }
+  public:
+        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
+        Entry( const WhileStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmtK ) {}
+        Entry( const CompoundStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
+        Entry( const IfStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
+        Entry( const CaseStmt *stmt, Label fallExit ) :
+                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
+        Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
+        Entry( const TryStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
+
+        bool isContTarget() const { return kind <= WhileStmtK; }
+        bool isBreakTarget() const { return kind != CaseStmtK; }
+        bool isFallTarget() const { return kind == CaseStmtK; }
+        bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
 
         // These routines set a target as being "used" by a BranchStmt
-        ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
-        ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
-        ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
-        ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
+        Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
+        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
+        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
+        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
 
         // These routines check if a specific label for a statement is used by a BranchStmt
-        bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
-        bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
-        bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
-        bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
+        bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
+        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
+        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
+        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
         void seenDefault() { fallDefaultValid = false; }
         bool isFallDefaultValid() const { return fallDefaultValid; }
 };
 
-// Helper predicates used in std::find_if calls (it doesn't take methods):
+// Helper predicates used in find_if calls (it doesn't take methods):
 bool isBreakTarget( const Entry & entry ) {
         return entry.isBreakTarget();
@@ -105 +104 @@
 
 struct MultiLevelExitCore final :
-                public ast::WithVisitorRef<MultiLevelExitCore>,
-                public ast::WithShortCircuiting, public ast::WithGuards {
+        public WithVisitorRef<MultiLevelExitCore>,
+        public WithShortCircuiting, public WithGuards {
         MultiLevelExitCore( const LabelToStmt & lt );
 
-        void previsit( const ast::FunctionDecl * );
-
-        const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
-        const ast::BranchStmt * postvisit( const ast::BranchStmt * );
-        void previsit( const ast::WhileStmt * );
-        const ast::WhileStmt * postvisit( const ast::WhileStmt * );
-        void previsit( const ast::ForStmt * );
-        const ast::ForStmt * postvisit( const ast::ForStmt * );
-        const ast::CaseStmt * previsit( const ast::CaseStmt * );
-        void previsit( const ast::IfStmt * );
-        const ast::IfStmt * postvisit( const ast::IfStmt * );
-        void previsit( const ast::SwitchStmt * );
-        const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
-        void previsit( const ast::ReturnStmt * );
-        void previsit( const ast::TryStmt * );
-        void postvisit( const ast::TryStmt * );
-        void previsit( const ast::FinallyStmt * );
-
-        const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
+        void previsit( const FunctionDecl * );
+
+        const CompoundStmt * previsit( const CompoundStmt * );
+        const BranchStmt * postvisit( const BranchStmt * );
+        void previsit( const WhileStmt * );
+        const WhileStmt * postvisit( const WhileStmt * );
+        void previsit( const ForStmt * );
+        const ForStmt * postvisit( const ForStmt * );
+        const CaseStmt * previsit( const CaseStmt * );
+        void previsit( const IfStmt * );
+        const IfStmt * postvisit( const IfStmt * );
+        void previsit( const SwitchStmt * );
+        const SwitchStmt * postvisit( const SwitchStmt * );
+        void previsit( const ReturnStmt * );
+        void previsit( const TryStmt * );
+        void postvisit( const TryStmt * );
+        void previsit( const FinallyStmt * );
+
+        const Stmt * mutateLoop( const Stmt * body, Entry& );
 
         const LabelToStmt & target_table;
-        std::set<ast::Label> fallthrough_labels;
-        std::vector<Entry> enclosing_control_structures;
-        ast::Label break_label;
+        set<Label> fallthrough_labels;
+        vector<Entry> enclosing_control_structures;
+        Label break_label;
         bool inFinally;
 
@@ -140 +139 @@
         const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
 
-        std::list<ast::ptr<ast::Stmt>> fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
+        list<ptr<Stmt>> fixBlock(
+                const list<ptr<Stmt>> & kids, bool caseClause );
 
         template<typename UnaryPredicate>
         auto findEnclosingControlStructure( UnaryPredicate pred ) {
-                return std::find_if( enclosing_control_structures.rbegin(),
-                        enclosing_control_structures.rend(), pred );
+                return find_if( enclosing_control_structures.rbegin(),
+                                                enclosing_control_structures.rend(), pred );
         }
 };
 
-ast::NullStmt * labelledNullStmt(
-                const CodeLocation & cl, const ast::Label & label ) {
-        return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
+NullStmt * labelledNullStmt(
+        const CodeLocation & cl, const Label & label ) {
+        return new NullStmt( cl, vector<Label>{ label } );
 }
 
@@ -160 +159 @@
 {}
 
-void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
+void MultiLevelExitCore::previsit( const FunctionDecl * ) {
         visit_children = false;
 }
 
-const ast::CompoundStmt * MultiLevelExitCore::previsit(
-                const ast::CompoundStmt * stmt ) {
+const CompoundStmt * MultiLevelExitCore::previsit(
+        const CompoundStmt * stmt ) {
         visit_children = false;
 
@@ -171 +170 @@
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
         }
 
-        auto mutStmt = ast::mutate( stmt );
+        auto mutStmt = mutate( stmt );
         // A child statement may set the break label.
-        mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
+        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
 
         if ( isLabeled ) {
@@ -191 +190 @@
 
 size_t getUnusedIndex(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+        const Stmt * stmt, const Label & originalTarget ) {
         const size_t size = stmt->labels.size();
 
-        // If the label is empty, we can skip adding the unused attribute:
-        if ( originalTarget.empty() ) return size;
+        // If the label is empty, do not add unused attribute.
+  if ( originalTarget.empty() ) return size;
 
         // Search for a label that matches the originalTarget.
         for ( size_t i = 0 ; i < size ; ++i ) {
-                const ast::Label & label = stmt->labels[i];
+                const Label & label = stmt->labels[i];
                 if ( label == originalTarget ) {
-                        for ( const ast::Attribute * attr : label.attributes ) {
+                        for ( const Attribute * attr : label.attributes ) {
                                 if ( attr->name == "unused" ) return size;
                         }
@@ -208 +207 @@
         }
         assertf( false, "Could not find label '%s' on statement %s",
-                originalTarget.name.c_str(), toString( stmt ).c_str() );
-}
-
-const ast::Stmt * addUnused(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+                         originalTarget.name.c_str(), toString( stmt ).c_str() );
+}
+
+const Stmt * addUnused(
+        const Stmt * stmt, const Label & originalTarget ) {
         size_t i = getUnusedIndex( stmt, originalTarget );
         if ( i == stmt->labels.size() ) {
                 return stmt;
         }
-        ast::Stmt * mutStmt = ast::mutate( stmt );
-        mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
+        Stmt * mutStmt = mutate( stmt );
+        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
         return mutStmt;
 }
@@ -224 +223 @@
 // This routine updates targets on enclosing control structures to indicate which
 //     label is used by the BranchStmt that is passed
-const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
-        std::vector<Entry>::reverse_iterator targetEntry =
+const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
+        vector<Entry>::reverse_iterator targetEntry =
                 enclosing_control_structures.rend();
 
         // Labels on different stmts require different approaches to access
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Goto:
+          case BranchStmt::Goto:
                 return stmt;
-        case ast::BranchStmt::Continue:
-        case ast::BranchStmt::Break: {
-                bool isContinue = stmt->kind == ast::BranchStmt::Continue;
-                // Handle unlabeled break and continue.
-                if ( stmt->target.empty() ) {
-                        if ( isContinue ) {
-                                targetEntry = findEnclosingControlStructure( isContinueTarget );
-                        } else {
-                                if ( enclosing_control_structures.empty() ) {
-                                        SemanticError( stmt->location,
-                                                "'break' outside a loop, 'switch', or labelled block" );
-                                }
-                                targetEntry = findEnclosingControlStructure( isBreakTarget );
-                        }
-                // Handle labeled break and continue.
-                } else {
-                        // Lookup label in table to find attached control structure.
-                        targetEntry = findEnclosingControlStructure(
-                                [ targetStmt = target_table.at(stmt->target) ](auto entry){
-                                        return entry.stmt == targetStmt;
-                                } );
-                }
-                // Ensure that selected target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
-                        SemanticError(
-                                stmt->location,
-                                toString( (isContinue ? "'continue'" : "'break'"),
-                                        " target must be an enclosing ",
-                                        (isContinue ? "loop: " : "control structure: "),
-                                        stmt->originalTarget ) );
-                }
-                break;
-        }
-        // handle fallthrough in case/switch stmts
-        case ast::BranchStmt::FallThrough: {
-                targetEntry = findEnclosingControlStructure( isFallthroughTarget );
-                // Check that target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-                if ( !stmt->target.empty() ) {
-                        // Labelled fallthrough: target must be a valid fallthough label.
-                        if ( !fallthrough_labels.count( stmt->target ) ) {
-                                SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
-                        }
-                        return new ast::BranchStmt(
-                                stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
-                }
-                break;
-        }
-        case ast::BranchStmt::FallThroughDefault: {
-                targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
-
-                // Check that this is in a switch or choose statement.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-
-                // Check that the switch or choose has a default clause.
-                auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
-                        targetEntry->stmt );
-                bool foundDefault = false;
-                for ( auto subStmt : switchStmt->stmts ) {
-                        const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
-                        if ( caseStmt->isDefault() ) {
-                                foundDefault = true;
-                                break;
-                        }
-                }
-                if ( !foundDefault ) {
-                        SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
-                }
-                break;
-        }
-        default:
+          case BranchStmt::Continue:
+          case BranchStmt::Break: {
+                  bool isContinue = stmt->kind == BranchStmt::Continue;
+                  // Handle unlabeled break and continue.
+                  if ( stmt->target.empty() ) {
+                          if ( isContinue ) {
+                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
+                          } else {
+                                  if ( enclosing_control_structures.empty() ) {
+                                          SemanticError( stmt->location,
+                                                                         "'break' outside a loop, 'switch', or labelled block" );
+                                  }
+                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
+                          }
+                          // Handle labeled break and continue.
+                  } else {
+                          // Lookup label in table to find attached control structure.
+                          targetEntry = findEnclosingControlStructure(
+                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
+                                          return entry.stmt == targetStmt;
+                                  } );
+                  }
+                  // Ensure that selected target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
+                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
+                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
+                                                        stmt->originalTarget ) );
+                  }
+                  break;
+          }
+          // handle fallthrough in case/switch stmts
+          case BranchStmt::FallThrough: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
+                  // Check that target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+                  if ( !stmt->target.empty() ) {
+                          // Labelled fallthrough: target must be a valid fallthough label.
+                          if ( !fallthrough_labels.count( stmt->target ) ) {
+                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
+                                                                                                                   stmt->originalTarget ) );
+                          }
+                          return new BranchStmt(
+                                  stmt->location, BranchStmt::Goto, stmt->originalTarget );
+                  }
+                  break;
+          }
+          case BranchStmt::FallThroughDefault: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
+
+                  // Check if in switch or choose statement.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+
+                  // Check if switch or choose has default clause.
+                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
+                  bool foundDefault = false;
+                  for ( auto subStmt : switchStmt->stmts ) {
+                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
+                          if ( caseStmt->isDefault() ) {
+                                  foundDefault = true;
+                                  break;
+                          }
+                  }
+                  if ( ! foundDefault ) {
+                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
+                                                         "control structure with a 'default' clause" );
+                  }
+                  break;
+          }
+          default:
                 assert( false );
         }
 
         // Branch error checks: get the appropriate label name:
-        // (This label will always be replaced.)
-        ast::Label exitLabel( CodeLocation(), "" );
+        // (This label is always replaced.)
+        Label exitLabel( CodeLocation(), "" );
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Break:
+          case BranchStmt::Break:
                 assert( !targetEntry->useBreakExit().empty() );
                 exitLabel = targetEntry->useBreakExit();
                 break;
-        case ast::BranchStmt::Continue:
+          case BranchStmt::Continue:
                 assert( !targetEntry->useContExit().empty() );
                 exitLabel = targetEntry->useContExit();
                 break;
-        case ast::BranchStmt::FallThrough:
+          case BranchStmt::FallThrough:
                 assert( !targetEntry->useFallExit().empty() );
                 exitLabel = targetEntry->useFallExit();
                 break;
-        case ast::BranchStmt::FallThroughDefault:
+          case BranchStmt::FallThroughDefault:
                 assert( !targetEntry->useFallDefaultExit().empty() );
                 exitLabel = targetEntry->useFallDefaultExit();
                 // Check that fallthrough default comes before the default clause.
                 if ( !targetEntry->isFallDefaultValid() ) {
-                        SemanticError( stmt->location,
-                                "'fallthrough default' must precede the 'default' clause" );
+                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
                 }
                 break;
-        default:
+          default:
                 assert(0);
         }
@@ -342 +338 @@
         targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
 
-        // Replace this with a goto to make later passes more uniform.
-        return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
-}
-
-void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
+        // Replace with goto to make later passes more uniform.
+        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
+}
+
+void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
+const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
 
-void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
+const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
@@ -364 +360 @@
 // Mimic what the built-in push_front would do anyways. It is O(n).
 void push_front(
-                std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
+        vector<ptr<Stmt>> & vec, const Stmt * element ) {
         vec.emplace_back( nullptr );
         for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
-                vec[ i ] = std::move( vec[ i - 1 ] );
+                vec[ i ] = move( vec[ i - 1 ] );
         }
         vec[ 0 ] = element;
 }
 
-const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
+const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
         visit_children = false;
 
-        // If it is the default, mark the default as seen.
+        // If default, mark seen.
         if ( stmt->isDefault() ) {
                 assert( !enclosing_control_structures.empty() );
@@ -382 +378 @@
 
         // The cond may not exist, but if it does update it now.
-        visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
+        visitor->maybe_accept( stmt, &CaseStmt::cond );
 
         // Just save the mutated node for simplicity.
-        ast::CaseStmt * mutStmt = ast::mutate( stmt );
-
-        ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
-        if ( !mutStmt->stmts.empty() ) {
+        CaseStmt * mutStmt = mutate( stmt );
+
+        Label fallLabel = newLabel( "fallThrough", stmt );
+        if ( ! mutStmt->stmts.empty() ) {
                 // Ensure that the stack isn't corrupted by exceptions in fixBlock.
                 auto guard = makeFuncGuard(
                         [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
                         [this](){ enclosing_control_structures.pop_back(); }
-                );
+                        );
 
                 // These should already be in a block.
-                auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
+                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
                 block->kids = fixBlock( block->kids, true );
 
                 // Add fallthrough label if necessary.
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 Entry & entry = enclosing_control_structures.back();
                 if ( entry.isFallUsed() ) {
@@ -407 +403 @@
                 }
         }
-        assert( !enclosing_control_structures.empty() );
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
-        assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
-                "Control structure enclosing a case clause must be a switch, but is: %s",
-                toString( entry.stmt ).c_str() );
+        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
+                         "Control structure enclosing a case clause must be a switch, but is: %s",
+                         toString( entry.stmt ).c_str() );
         if ( mutStmt->isDefault() ) {
                 if ( entry.isFallDefaultUsed() ) {
                         // Add fallthrough default label if necessary.
                         push_front( mutStmt->stmts, labelledNullStmt(
-                                stmt->location, entry.useFallDefaultExit()
-                        ) );
+                                                        stmt->location, entry.useFallDefaultExit()
+                                                        ) );
                 }
         }
@@ -423 +419 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
+void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
         bool labeledBlock = !stmt->labels.empty();
         if ( labeledBlock ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
@@ -432 +428 @@
 }
 
-const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
+const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
         bool labeledBlock = !stmt->labels.empty();
         if ( labeledBlock ) {
@@ -443 +439 @@
 }
 
-bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
-        const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
+bool isDefaultCase( const ptr<Stmt> & stmt ) {
+        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
         return caseStmt->isDefault();
 }
 
-void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
-        ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
-        auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
-
-        const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
-                ? (it)->strict_as<ast::CaseStmt>() : nullptr;
-        ast::Label defaultLabel = defaultCase
-                ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
-                : ast::Label( stmt->location, "" );
+void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
+        Label label = newLabel( "switchBreak", stmt );
+        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
+
+        const CaseStmt * defaultCase = it != stmt->stmts.rend()
+                ? (it)->strict_as<CaseStmt>() : nullptr;
+        Label defaultLabel = defaultCase
+                ? newLabel( "fallThroughDefault", defaultCase )
+                : Label( stmt->location, "" );
         enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
         GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
 
         // Collect valid labels for fallthrough. It starts with all labels at
-        // this level, then removed as we see them in traversal.
-        for ( const ast::Stmt * stmt : stmt->stmts ) {
-                auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
+        // this level, then remove as each is seen during traversal.
+        for ( const Stmt * stmt : stmt->stmts ) {
+                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
                 if ( caseStmt->stmts.empty() ) continue;
-                auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
-                for ( const ast::Stmt * stmt : block->kids ) {
-                        for ( const ast::Label & l : stmt->labels ) {
+                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
+                for ( const Stmt * stmt : block->kids ) {
+                        for ( const Label & l : stmt->labels ) {
                                 fallthrough_labels.insert( l );
                         }
@@ -474 +470 @@
 }
 
-const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
+const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
         assert( !enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == stmt );
 
-        // Only run if we need to generate the break label.
+        // Only run to generate the break label.
         if ( entry.isBreakUsed() ) {
                 // To keep the switch statements uniform (all direct children of a
                 // SwitchStmt should be CastStmts), append the exit label and break
                 // to the last case, create a default case is there are no cases.
-                ast::SwitchStmt * mutStmt = ast::mutate( stmt );
+                SwitchStmt * mutStmt = mutate( stmt );
                 if ( mutStmt->stmts.empty() ) {
-                        mutStmt->stmts.push_back( new ast::CaseStmt(
-                                mutStmt->location, nullptr, {} ));
-                }
-
-                auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
-                auto mutCase = ast::mutate( caseStmt );
+                        mutStmt->stmts.push_back( new CaseStmt(
+                                                                                  mutStmt->location, nullptr, {} ));
+                }
+
+                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
+                auto mutCase = mutate( caseStmt );
                 mutStmt->stmts.back() = mutCase;
 
-                ast::Label label( mutCase->location, "breakLabel" );
-                auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
+                Label label( mutCase->location, "breakLabel" );
+                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
                 branch->labels.push_back( entry.useBreakExit() );
                 mutCase->stmts.push_back( branch );
@@ -504 +500 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
         if ( inFinally ) {
                 SemanticError( stmt->location, "'return' may not appear in a finally clause" );
@@ -510 +506 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
+void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
@@ -519 +515 @@
 }
 
-void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
+void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
@@ -529 +525 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
-        GuardAction([this, old = std::move(enclosing_control_structures)](){
-                enclosing_control_structures = std::move(old);
-        });
-        enclosing_control_structures = std::vector<Entry>();
+void MultiLevelExitCore::previsit( const FinallyStmt * ) {
+        GuardAction([this, old = move(enclosing_control_structures)](){
+                                        enclosing_control_structures = move(old);
+                                });
+        enclosing_control_structures = vector<Entry>();
         GuardValue( inFinally ) = true;
 }
 
-const ast::Stmt * MultiLevelExitCore::mutateLoop(
-                const ast::Stmt * body, Entry & entry ) {
+const Stmt * MultiLevelExitCore::mutateLoop(
+        const Stmt * body, Entry & entry ) {
         if ( entry.isBreakUsed() ) {
                 break_label = entry.useBreakExit();
@@ -545 +541 @@
         // if continue is used insert a continue label into the back of the body of the loop
         if ( entry.isContUsed() ) {
-                ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
+                CompoundStmt * new_body = new CompoundStmt( body->location );
                 // {}
                 new_body->kids.push_back( body );
@@ -567 +563 @@
         // Remember is loop before going onto mutate the body.
         // The labels will be folded in if they are used.
-        ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
-        ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
+        Label breakLabel = newLabel( "loopBreak", loopStmt );
+        Label contLabel = newLabel( "loopContinue", loopStmt );
         enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
         // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
@@ -583 +579 @@
         assert( entry.stmt == loopStmt );
 
-        // Now we check if the labels are used and add them if so.
-        return ast::mutate_field(
+        // Now check if the labels are used and add them if so.
+        return mutate_field(
                 loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
         // this call to mutate_field compares loopStmt->body and the result of mutateLoop
@@ -591 +587 @@
 }
 
-std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
-        // Unfortunately we can't use the automatic error collection.
+list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
+        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
+        // Unfortunately cannot use automatic error collection.
         SemanticErrorException errors;
 
-        std::list<ast::ptr<ast::Stmt>> ret;
+        list<ptr<Stmt>> ret;
 
         // Manually visit each child.
-        for ( const ast::ptr<ast::Stmt> & kid : kids ) {
+        for ( const ptr<Stmt> & kid : kids ) {
                 if ( is_case_clause ) {
                         // Once a label is seen, it's no longer a valid for fallthrough.
-                        for ( const ast::Label & l : kid->labels ) {
+                        for ( const Label & l : kid->labels ) {
                                 fallthrough_labels.erase( l );
                         }
@@ -616 +612 @@
                         ret.push_back(
                                 labelledNullStmt( ret.back()->location, break_label ) );
-                        break_label = ast::Label( CodeLocation(), "" );
+                        break_label = Label( CodeLocation(), "" );
                 }
         }
@@ -626 +622 @@
 }
 
-} // namespace
-
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt * stmt,
-                const LabelToStmt & labelTable ) {
+const CompoundStmt * multiLevelExitUpdate(
+        const CompoundStmt * stmt,
+        const LabelToStmt & labelTable ) {
         // Must start in the body, so FunctionDecls can be a stopping point.
-        ast::Pass<MultiLevelExitCore> visitor( labelTable );
-        const ast::CompoundStmt * ret = stmt->accept( visitor );
+        Pass<MultiLevelExitCore> visitor( labelTable );
+        const CompoundStmt * ret = stmt->accept( visitor );
         return ret;
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:49:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:34:06 2022
+// Update Count     : 6
 //
 
@@ -19 +19 @@
 
 namespace ast {
-        class CompoundStmt;
-        class Label;
-        class Stmt;
+class CompoundStmt;
+class Label;
+class Stmt;
 }
 
 namespace ControlStruct {
-
 using LabelToStmt = std::map<ast::Label, const ast::Stmt *>;
 
-/// Mutate a function body to handle multi-level exits.
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt *, const LabelToStmt & );
-
+// Mutate a function body to handle multi-level exits.
+const ast::CompoundStmt * multiLevelExitUpdate( const ast::CompoundStmt *, const LabelToStmt & );
 }
 

src/ControlStruct/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Henry Xue
-## Last Modified On : Tue Jul 20 04:10:50 2021
-## Update Count     : 5
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat Jan 29 12:04:19 2022
+## Update Count     : 7
 ###############################################################################
 
@@ -28 +28 @@
         ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelGenerator.h \
+        ControlStruct/LabelGeneratorNew.cpp \
+        ControlStruct/LabelGeneratorNew.hpp \
         ControlStruct/MLEMutator.cc \
         ControlStruct/MLEMutator.h \

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 14 17:28:53 2021
-// Update Count     : 900
+// Last Modified On : Sat Jan 29 09:45:56 2022
+// Update Count     : 901
 //
 
@@ -390 +390 @@
 Statement * build_expr( ExpressionNode * ctl );
 
-struct IfCtrl {
-        IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
+struct CondCtl {
+        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
                 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
 
@@ -409 +409 @@
 };
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
+Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
 Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_case( ExpressionNode * ctl );
 Statement * build_default();
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
+Statement * build_while( CondCtl * ctl, StatementNode * stmt );
 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_for( ForCtrl * forctl, StatementNode * stmt );

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct 24 04:20:55 2020
-// Update Count     : 383
+// Last Modified On : Sat Jan 29 09:45:51 2022
+// Update Count     : 384
 //
 
@@ -78 +78 @@
 } // build_expr
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init ) {
+Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init ) {
         if ( ctl->init != 0 ) {
                 buildMoveList( ctl->init, init );
@@ -100 +100 @@
 } // build_if_control
 
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
+Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
         Statement * thenb, * elseb = nullptr;
         std::list< Statement * > branches;
@@ -145 +145 @@
 } // build_default
 
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt ) {
+Statement * build_while( CondCtl * ctl, StatementNode * stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 15 09:20:17 2021
-// Update Count     : 5163
+// Last Modified On : Sun Jan 30 09:41:13 2022
+// Update Count     : 5165
 //
 
@@ -238 +238 @@
         WaitForStmt * wfs;
         Expression * constant;
-        IfCtrl * ifctl;
+        CondCtl * ifctl;
         ForCtrl * fctl;
         enum OperKinds compop;
@@ -327 +327 @@
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
-%type<ifctl> if_control_expression
+%type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> inclexcl
@@ -1123 +1123 @@
 
 if_statement:
-        IF '(' if_control_expression ')' statement                      %prec THEN
+        IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
-        | IF '(' if_control_expression ')' statement ELSE statement
+        | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
-if_control_expression:
+conditional_declaration:
         comma_expression
-                { $$ = new IfCtrl( nullptr, $1 ); }
+                { $$ = new CondCtl( nullptr, $1 ); }
         | c_declaration                                                                         // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | cfa_declaration                                                                       // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | declaration comma_expression                                          // semi-colon separated
-                { $$ = new IfCtrl( $1, $2 ); }
+                { $$ = new CondCtl( $1, $2 ); }
         ;
 
@@ -1193 +1193 @@
 iteration_statement:
         WHILE '(' ')' statement                                                         // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )

tests/concurrent/preempt.cfa

@@ +1 @@
+#include <clock.hfa>
 #include <fstream.hfa>
 #include <kernel.hfa>
@@ -22 +23 @@
 extern void __cfaabi_check_preemption();
 
-static volatile int counter = 0;
+static struct {
+        volatile int counter;
+        volatile Time prev;
+        Duration durations[6];
+} globals;
 
 thread worker_t {
         int value;
-        unsigned spin;
+        unsigned long long spin;
 };
 
@@ -35 +40 @@
 
 void main(worker_t & this) {
-        while(TEST(counter < N)) {
-                if(this.spin > 100_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
+        while(TEST(globals.counter < N)) {
+                if(this.spin > 50_000_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
                 __cfaabi_check_preemption();
-                if( (counter % 7) == this.value ) {
+                if( (globals.counter % 7) == this.value ) {
                         __cfaabi_check_preemption();
-                        int next = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
+                        #if !defined(TEST_LONG)
+                                Time now = timeHiRes();
+                                Duration diff = now - globals.prev;
+                                globals.prev = now;
+                        #endif
+                        int next = __atomic_add_fetch( &globals.counter, 1, __ATOMIC_SEQ_CST );
                         __cfaabi_check_preemption();
-                        if( (next % 100) == 0 ) printf("%d\n", (int)next);
+                        if( (next % 100) == 0 ) {
+                                #if !defined(TEST_LONG)
+                                        unsigned idx = next / 100;
+                                        if (idx >= 6) abort | "Idx from next is invalid: " | idx | "vs" | next;
+                                        globals.durations[idx] = diff;
+                                        if(diff > 12`s) serr | "Duration suspiciously large:" | diff;
+                                #endif
+                                printf("%d\n", (int)next);
+
+                        }
                         __cfaabi_check_preemption();
                         this.spin = 0;
@@ -54 +73 @@
 int main(int argc, char* argv[]) {
         processor p;
+        globals.counter = 0;
+        globals.durations[0] = 0;
+        globals.durations[1] = 0;
+        globals.durations[2] = 0;
+        globals.durations[3] = 0;
+        globals.durations[4] = 0;
+        globals.durations[5] = 0;
         {
+                globals.prev = timeHiRes();
                 worker_t w0 = 0;
                 worker_t w1 = 1;

tools/auto-complete.md

@@ -32 +32 @@
 
 ### Zsh
+
+1 - Add the following somewhere:
+    #compdef test.py
+
+    _test_py() {
+        local -a options
+        options=$($words[1] --list-comp)
+        _alternative "files:filenames:($options)"
+    }
+
+    _test_py "$@"
+
+2 - Add the path to that file to the "fpath" environment variable.
+
+3 - In ~/.zshrc add
+    autoload -U compinit
+    compinit
+
+*How it works:* I don't know ;P
+
+