Changeset d67cdb7

doc/proposals/concurrency/Makefile

r201aeb9	rd67cdb7
17	17	text/concurrency \
18	18	text/parallelism \
	19	text/together \
	20	text/future \
19	21	}
20	22

doc/proposals/concurrency/annex/glossary.tex

r201aeb9	rd67cdb7
101	101	\newacronym{api}{API}{Application Program Interface}
102	102	\newacronym{raii}{RAII}{Ressource Acquisition Is Initialization}
	103	\newacronym{numa}{NUMA}{Non-Uniform Memory Access}

doc/proposals/concurrency/text/cforall.tex

-              r201aeb9
+              rd67cdb7
 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
 &r1 = x,    &&r2 = r1,   &&&r3 = r2;
 ***p3 = 3;                                      // change x
 r3 = 3;                                         // change x, ***r3
 **p3 = ...;                                     // change p1
 &r3 = ...;                                      // change r1, (&*)**r3
 *p3 = ...;                                      // change p2
 &&r3 = ...;                                     // change r2, (&(&*)*)*r3
 &&&r3 = p3;                                     // change r3 to p3, (&(&(&*)*)*)r3
 int y, z, & ar[3] = { x, y, z };                // initialize array of references
 &ar[1] = &z;                                    // change reference array element
 typeof( ar[1] ) p;                              // is int, i.e., the type of referenced object
 typeof( &ar[1] ) q;                             // is int &, i.e., the type of reference
 sizeof( ar[1] ) == sizeof( int );               // is true, i.e., the size of referenced object
 sizeof( &ar[1] ) == sizeof( int *);             // is true, i.e., the size of a reference
+***p3 = 3;                              // change x
+r3 = 3;                                 // change x, ***r3
+**p3 = ...;                             // change p1
+&r3 = ...;                              // change r1, (&*)**r3
+*p3 = ...;                              // change p2
+&&r3 = ...;                             // change r2, (&(&*)*)*r3
+&&&r3 = p3;                             // change r3 to p3, (&(&(&*)*)*)r3
+int y, z, & ar[3] = { x, y, z };        // initialize array of references
+&ar[1] = &z;                            // change reference array element
+typeof( ar[1] ) p;                      // is int, i.e., the type of referenced object
+typeof( &ar[1] ) q;                     // is int &, i.e., the type of reference
+sizeof( ar[1] ) == sizeof( int );       // is true, i.e., the size of referenced object
+sizeof( &ar[1] ) == sizeof( int *);     // is true, i.e., the size of a reference
 \end{cfacode}
 The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient.
 …
 \begin{cfacode}
 // selection based on type and number of parameters
 void f( void );                                 // (1)
 void f( char );                                 // (2)
 void f( int, double );                          // (3)
 f();                                            // select (1)
 f( 'a' );                                       // select (2)
 f( 3, 5.2 );                                    // select (3)
+void f( void );                         // (1)
+void f( char );                         // (2)
+void f( int, double );                  // (3)
+f();                                    // select (1)
+f( 'a' );                               // select (2)
+f( 3, 5.2 );                            // select (3)
 // selection based on  type and number of returns
 char f( int );                                  // (1)
 double f( int );                                // (2)
 [ int, double ] f( int );                       // (3)
 char c = f( 3 );                                // select (1)
 double d = f( 4 );                              // select (2)
 [ int, double ] t = f( 5 );                     // select (3)
+char f( int );                          // (1)
+double f( int );                        // (2)
+[ int, double ] f( int );               // (3)
+char c = f( 3 );                        // select (1)
+double d = f( 4 );                      // select (2)
+[ int, double ] t = f( 5 );             // select (3)
 \end{cfacode}
 This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced.
 …
 Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so :
 \begin{cfacode}
 int ++?( int op );                              // unary prefix increment
 int ?++( int op );                              // unary postfix increment
 int ?+?( int op1, int op2 );                    // binary plus
 int ?<=?( int op1, int op2 );                   // binary less than
 int ?=?( int & op1, int op2 );                  // binary assignment
 int ?+=?( int & op1, int op2 );                 // binary plus-assignment
+int ++?( int op );                      // unary prefix increment
+int ?++( int op );                      // unary postfix increment
+int ?+?( int op1, int op2 );            // binary plus
+int ?<=?( int op1, int op2 );           // binary less than
+int ?=?( int & op1, int op2 );          // binary assignment
+int ?+=?( int & op1, int op2 );         // binary plus-assignment
 struct S { int i, j; };
 S ?+?( S op1, S op2 ) {                         // add two structures
+S ?+?( S op1, S op2 ) {                 // add two structures
         return (S){ op1.i + op2.i, op1.j + op2.j };
+}
 S s1 = { 1, 2 }, s2 = { 2, 3 }, s3;
 s3 = s1 + s2;                                   // compute sum: s3 == { 2, 5 }
+s3 = s1 + s2;                           // compute sum: s3 == { 2, 5 }
 \end{cfacode}
 …
 \section{Constructors/Destructors}
 \CFA uses the following syntax for constructors and destructors :
+Object life time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, Constructors \& Destructors are a the core of the features required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors :
 \begin{cfacode}
 struct S {
 …
         int * ia;
 };
 void ?{}( S & s, int asize ) with s {           // constructor operator
         size = asize;                           // initialize fields
+void ?{}( S & s, int asize ) with s {   // constructor operator
+        size = asize;                   // initialize fields
         ia = calloc( size, sizeof( S ) );
+}
 void ^?{}( S & s ) with s {                     // destructor operator
         free( ia );                             // de-initialization fields
+void ^?{}( S & s ) with s {             // destructor operator
+        free( ia );                     // de-initialization fields
+}
 int main() {
         S x = { 10 }, y = { 100 };              // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
         ...                                     // use x and y
         ^x{};  ^y{};                            // explicit calls to de-initialize
         x{ 20 };  y{ 200 };                     // explicit calls to reinitialize
         ...                                     // reuse x and y
 }                                               // implict calls: ^?{}( y ), ^?{}( x )
+        S x = { 10 }, y = { 100 };      // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
+        ...                             // use x and y
+        ^x{};  ^y{};                    // explicit calls to de-initialize
+        x{ 20 };  y{ 200 };             // explicit calls to reinitialize
+        ...                             // reuse x and y
+}                                       // implict calls: ^?{}( y ), ^?{}( x )
 \end{cfacode}
 The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope.

doc/proposals/concurrency/text/concurrency.tex

-              r201aeb9
+              rd67cdb7
 int f5(graph(monitor*) & mutex m);
 \end{cfacode}
 The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
 \begin{cfacode}
 …
 % ======================================================================
 % ======================================================================
 There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
+There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem \cite{Chicken} of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
 The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively.
 …
 To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
+% ======================================================================
+% ======================================================================
+\section{Other concurrency tools}
+% ======================================================================
+% ======================================================================
+% \TODO
+\subsection{Internals}
+The complete mask can be pushed to any one, we are in a context where we already have full ownership of (at least) every concerned monitor and therefore monitors will refuse all calls no matter what.

doc/proposals/concurrency/text/intro.tex

-              r201aeb9
+              rd67cdb7
 % ======================================================================
 This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adapted in \CFA
+This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adopted in \CFA
 There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the users. While these two concepts are often combined, they are in fact distinct concepts that require different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.
+There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmers. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.

doc/proposals/concurrency/text/parallelism.tex

-              r201aeb9
+              rd67cdb7
 \section{Paradigm}
 \subsection{User-level threads}
 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
+A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensive costs of kernel threads. The down side is that almost none of the low-level threading problems are hidden; users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
 Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
 \subsection{Fibers : user-level threads without preemption}
 A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
+A popular varient of \glspl{uthread} is what is often refered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial, and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
 An example of a language that uses fibers is Go~\cite{Go}
 \subsection{Jobs and thread pools}
 The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
+The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work, called jobs, and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
 The gold standard of this implementation is Intel's TBB library~\cite{TBB}.
 \subsection{Paradigm performance}
 While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done.
+While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead (i.e., not thread stack per job). However, interactions among jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches is more expansive and the extra control means users need to tweak more variables to get the desired performance. Finally, if the units of uninterrupted work are large enough the paradigm choice is largely amortised by the actual work done.
-\newpage
 \TODO
+\subsection{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\section{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\subsubsection{Future Work: Machine setup}\label{machine}
+While this was not done in the context of this proposal, another important aspect of clusters is affinity. While many common desktop and laptop PCs have homogeneous CPUs, other devices often have more heteregenous setups. For example, system using \acrshort{numa} configurations may benefit from users being able to tie clusters and/or kernel threads to certains CPU cores. OS support for CPU affinity is now common \cit, which means it is both possible and desirable for \CFA to offer an abstraction mechanism for portable CPU affinity.
 \subsection{Paradigms}\label{cfaparadigms}
+Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application.
+% \subsection{High-level options}\label{tasks}
+%
+% \subsubsection{Thread interface}
+% constructors destructors
+%       initializer lists
+% monitors
+%
+% \subsubsection{Futures}
+%
+% \subsubsection{Implicit threading}
+% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level.
+%
+% \begin{center}
+% \begin{tabular}[t]{|c|c|c|}
+% Sequential & System Parallel & Language Parallel \\
+% \begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for(int i = 0; i < length; ++i ) {
+%               out[i] = a[i] + b[i];
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting} &\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       range ar(a, a + length);
+%       range br(b, b + length);
+%       range or(out, out + length);
+%       parfor( ai, bi, oi,
+%       [](int* ai, int* bi, int* oi) {
+%               oi = ai + bi;
+%       });
+% }
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}&\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for (ai, bi, oi) in (a, b, out) {
+%               oi = ai + bi;
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}
+% \end{tabular}
+% \end{center}
+%
+% \subsection{Machine setup}\label{machine}
+% Threads are all good and well but wee still some OS support to fully utilize available hardware.
+%
+% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
+Given these building blocks, it is possible to reproduce all three of the popular paradigms. Indeed, \glspl{uthread} is the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. Finally, it is possible to build executors for thread pools from \glspl{uthread} or \glspl{fiber}.

doc/proposals/concurrency/thesis.tex

-              r201aeb9
+              rd67cdb7
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
 % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
 % LaTex escape §...§ (section symbol) emacs: C-q M-'
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
+% inline code �...� (copyright symbol) emacs: C-q M-)
+% red highlighting �...� (registered trademark symbol) emacs: C-q M-.
+% blue highlighting �...� (sharp s symbol) emacs: C-q M-_
+% green highlighting �...� (cent symbol) emacs: C-q M-"
+% LaTex escape �...� (section symbol) emacs: C-q M-'
+% keyword escape �...� (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
 …
 \usepackage{multicol}
 \usepackage[acronym]{glossaries}
 \usepackage{varioref}
+\usepackage{varioref}
 \usepackage{listings}                                           % format program code
 \usepackage[flushmargin]{footmisc}                              % support label/reference in footnote
 …
 \input{parallelism}
+\chapter{Putting it all together}
+\input{together}
+\input{future}
 \chapter{Conclusion}
-\chapter{Future work}
-Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA.
-\subsection{Transactions}
 \section*{Acknowledgements}

doc/proposals/concurrency/version

r201aeb9	rd67cdb7
1		0.~~9.180~~
	1	0.10.2

src/CodeGen/CodeGenerator.cc

-              r201aeb9
+              rd67cdb7
         void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
+                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
                         OperatorInfo opInfo;
                         if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
+                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         (*arg++)->accept( *visitor );
                                         output << "[";
 …
                                   case OT_CTOR:
                                   case OT_DTOR:
                                         if ( untypedExpr->get_args().size() == 1 ) {
+                                        if ( untypedExpr->args.size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor may contain side
                                                 // effects, so must still output this expression
 …
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol << "{ ";
                                                 genCommaList( arg, untypedExpr->get_args().end() );
+                                                genCommaList( arg, untypedExpr->args.end() );
                                                 output << "}) /* " << opInfo.inputName << " */";
                                         } // if
 …
                                   case OT_PREFIXASSIGN:
                                   case OT_LABELADDRESS:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
 …
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
 …
                                   case OT_INFIX:
                                   case OT_INFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         output << "(";
                                         (*arg++)->accept( *visitor );
 …
                                 } // switch
                         } else {
+                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
+                                        assert( untypedExpr->get_args().size() == 2 );
+                                        (*untypedExpr->get_args().begin())->accept( *visitor );
+                                        output << " ... ";
+                                        (*--untypedExpr->get_args().end())->accept( *visitor );
+                                } else {                                                                // builtin routines
+                                        nameExpr->accept( *visitor );
+                                        output << "(";
+                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                                        output << ")";
+                                } // if
+                                // builtin routines
+                                nameExpr->accept( *visitor );
+                                output << "(";
+                                genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
+                                output << ")";
                         } // if
                 } else {
                         untypedExpr->get_function()->accept( *visitor );
+                        untypedExpr->function->accept( *visitor );
                         output << "(";
                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                        genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
                         output << ")";
                 } // if
 …
         void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
                 rangeExpr->get_low()->accept( *visitor );
+                rangeExpr->low->accept( *visitor );
                 output << " ... ";
                 rangeExpr->get_high()->accept( *visitor );
+                rangeExpr->high->accept( *visitor );
+        }
 …
         void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
+                updateLocation( caseStmt );
+                output << indent;
                 if ( caseStmt->isDefault()) {
                         output << "default";
 …
 } // namespace CodeGen
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
+        if ( node ) {
+                node->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/Concurrency/Keywords.cc

r201aeb9	rd67cdb7
528	528	DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
529	529	auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
530		~~// if( type ) std::cerr << "FRED2" << std::endl;~~
531	530	if( type && type->get_baseStruct()->is_thread() ) {
532	531	addStartStatement( decl, param );

src/Concurrency/Waitfor.cc

-              r201aeb9
+              rd67cdb7
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
+#include "ResolvExpr/Resolver.h"   // for findVoidExpression
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
 …
         //=============================================================================================
         class GenerateWaitForPass final : public WithStmtsToAdd {
+        class GenerateWaitForPass final : public WithIndexer {
           public:
 …
                 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
+                ObjectDecl * declareFlag( CompoundStmt * stmt );
+                Statement  * makeSetter( ObjectDecl * flag );
                 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt );
                 Expression * call();
                 void choose();
+                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
+                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
+                Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
+                void         choose( WaitForStmt * waitfor, Expression  * result, CompoundStmt * stmt );
                 static void implement( std::list< Declaration * > & translationUnit ) {
 …
           private:
                 FunctionDecl        * decl_waitfor    = nullptr;
+                StructDecl          * decl_mask       = nullptr;
                 StructDecl          * decl_acceptable = nullptr;
                 StructDecl          * decl_monitor    = nullptr;
-                DeclarationWithType * decl_m_func     = nullptr;
-                DeclarationWithType * decl_m_count    = nullptr;
-                DeclarationWithType * decl_m_monitors = nullptr;
-                DeclarationWithType * decl_m_isdtor   = nullptr;
                 static std::unique_ptr< Type > generic_func;
+                UniqueName namer_acc = "__acceptables_"s;
+                UniqueName namer_idx = "__index_"s;
+                UniqueName namer_flg = "__do_run_"s;
+                UniqueName namer_msk = "__mask_"s;
                 UniqueName namer_mon = "__monitors_"s;
-                UniqueName namer_acc = "__acceptables_"s;
                 UniqueName namer_tim = "__timeout_"s;
         };
 …
         namespace {
                 Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                 new NameExpr( "?[?]" ),
+                                {
 …
                 Expression * makeOpAssign( Expression * lhs, Expression * rhs ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                         new NameExpr( "?=?" ),
                                         { lhs, rhs }
 …
+                }
+                Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) {
+                        return new MemberExpr( mem, sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) {
+                        return new ExprStmt(
+                                noLabels,
+                                makeOpAssign(
+                                        makeOpMember(
+                                                makeOpIndex(
+                                                        object,
+                                                        index
+                                                ),
+                                                member
+                Expression * makeOpMember( Expression * sue, const std::string & mem ) {
+                        return new UntypedMemberExpr( new NameExpr( mem ), sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
+                        std::unique_ptr< Expression > expr( makeOpAssign(
+                                makeOpMember(
+                                        makeOpIndex(
+                                                object,
+                                                index
                                         ),
+                                        value
+                                )
+                        );
+                                        member
+                                ),
+                                value
+                        ) );
+                        return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
+                }
 …
                         return new ConstantExpr( Constant::from_bool( ifnull ) );
+                }
+                VariableExpr * extractVariable( Expression * func ) {
+                        if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) {
+                                return var;
+                        }
+                        CastExpr * cast = strict_dynamic_cast< CastExpr * >( func );
+                        return strict_dynamic_cast< VariableExpr * >( cast->arg );
+                }
+                Expression * detectIsDtor( Expression * func ) {
+                        VariableExpr * typed_func = extractVariable( func );
+                        bool is_dtor = InitTweak::isDestructor( typed_func->var );
+                        return new ConstantExpr( Constant::from_bool( is_dtor ) );
+                }
         };
 …
         void GenerateWaitForPass::premutate( FunctionDecl * decl) {
                 if( decl->name != "__accept_internal" ) return;
+                if( decl->name != "__waitfor_internal" ) return;
                 decl_waitfor = decl;
 …
                         assert( !decl_acceptable );
                         decl_acceptable = decl;
+                        for( Declaration * field : decl_acceptable->members ) {
+                                     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
+                        }
+                }
+                else if( decl->name == "__waitfor_mask_t" ) {
+                        assert( !decl_mask );
+                        decl_mask = decl;
+                }
                 else if( decl->name == "monitor_desc" ) {
 …
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
+                return waitfor;
+                if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
                 CompoundStmt * stmt = new CompoundStmt( noLabels );
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
+                ObjectDecl * flag        = declareFlag( stmt );
+                Statement  * setter      = makeSetter( flag );
                 int index = 0;
                 for( auto & clause : waitfor->clauses ) {
                         init( acceptables, index, clause, stmt );
+                        init( acceptables, index, clause, setter, stmt );
                         index++;
 …
                         waitfor->orelse .statement,
                         waitfor->orelse .condition,
+                        setter,
                         stmt
                 );
+                // Expression * result  = call( acceptables, timeout, orelse, stmt );
+                // choose( waitfor, result );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                stmt->push_back( new IfStmt(
+                        noLabels,
+                        safeCond( new VariableExpr( flag ) ),
+                        compound,
+                        nullptr
+                ));
+                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
+                choose( waitfor, result, compound );
                 return stmt;
 …
         ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
+        {
                 ObjectDecl * acceptables = new ObjectDecl(
+                ObjectDecl * acceptables = ObjectDecl::newObject(
                         namer_acc.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
 …
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
+                UntypedExpr * set = new UntypedExpr(
+                        new NameExpr( "__builtin_memset" ),
+                        {
+                                new VariableExpr( acceptables ),
+                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                new SizeofExpr( new VariableExpr( acceptables ) )
+                        }
+                );
+                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
+                delete set;
+                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
                 return acceptables;
+        }
+        ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
+                ObjectDecl * flag = ObjectDecl::newObject(
+                        namer_flg.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::Bool
+                        ),
+                        new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
+                );
+                stmt->push_back( new DeclStmt( noLabels, flag) );
+                return flag;
+        }
+        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
+                Expression * untyped = new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new VariableExpr( flag ),
+                                new ConstantExpr( Constant::from_ulong( 1 ) )
+                        }
+                );
+                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
+                delete untyped;
+                return new ExprStmt( noLabels, expr );
+        }
         ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
                 ObjectDecl * mon = new ObjectDecl(
+                ObjectDecl * mon = ObjectDecl::newObject(
                         namer_mon.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
                                 new StructInstType(
+                                new PointerType(
                                         noQualifiers,
+                                        decl_monitor
+                                        new StructInstType(
+                                                noQualifiers,
+                                                decl_monitor
+                                        )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
 …
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
+                                        return new SingleInit( expr );
+                                        Expression * untyped = new CastExpr(
+                                                new UntypedExpr(
+                                                        new NameExpr( "get_monitor" ),
+                                                        { expr }
+                                                ),
+                                                new PointerType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_monitor
+                                                        )
+                                                )
+                                        );
+                                        Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
+                                        delete untyped;
+                                        return new SingleInit( init );
                                 })
+                        )
 …
+        }
         void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
+        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
                 ObjectDecl * monitors = declMon( clause, stmt );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_func    , clause.target.function ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_count   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor  , new ConstantExpr( Constant::from_bool( true ) ) ) );
+                Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
                 stmt->push_back( new IfStmt(
                         noLabels,
                         safeCond( clause.condition ),
+                        compound,
+                        new CompoundStmt({
+                                makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
+                                setter->clone()
+                        }),
                         nullptr
                 ));
 …
                 bool has_else,
                 Expression *& else_cond,
+                Statement * setter,
                 CompoundStmt * stmt
         ) {
                 ObjectDecl * timeout = new ObjectDecl(
+                ObjectDecl * timeout = ObjectDecl::newObject(
                         namer_tim.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new BasicType(
                                 noQualifiers,
 …
                         stmt->push_back( new IfStmt(
                                 noLabels,
+                                safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                time
+                                        )
+                                ),
+                                safeCond( time_cond ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        time
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
                                 noLabels,
                                 safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                new ConstantExpr( Constant::from_ulong( 0 ) )
+                                        )
+                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        new ConstantExpr( Constant::from_ulong( 0 ) )
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
+                }
+                delete setter;
                 return new VariableExpr( timeout );
+        }
+        Expression * GenerateWaitForPass::call(
+                size_t count,
+                ObjectDecl * acceptables,
+                Expression * timeout,
+                CompoundStmt * stmt
+        ) {
+                ObjectDecl * index = ObjectDecl::newObject(
+                        namer_idx.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::ShortSignedInt
+                        ),
+                        new SingleInit(
+                                new ConstantExpr( Constant::from_int( -1 ) )
+                        )
+                );
+                stmt->push_back( new DeclStmt( noLabels, index ) );
+                ObjectDecl * mask = ObjectDecl::newObject(
+                        namer_msk.newName(),
+                        new StructInstType(
+                                noQualifiers,
+                                decl_mask
+                        ),
+                        new ListInit({
+                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
+                                new SingleInit( new VariableExpr( acceptables ) ),
+                                new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
+                        })
+                );
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
+                stmt->push_back( new ExprStmt(
+                        noLabels,
+                        new ApplicationExpr(
+                                VariableExpr::functionPointer( decl_waitfor ),
+                                {
+                                        new CastExpr(
+                                                new VariableExpr( mask ),
+                                                new ReferenceType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_mask
+                                                        )
+                                                )
+                                        ),
+                                        timeout
+                                }
+                        )
+                ));
+                return new VariableExpr( index );
+        }
+        void GenerateWaitForPass::choose(
+                WaitForStmt * waitfor,
+                Expression  * result,
+                CompoundStmt * stmt
+        ) {
+                SwitchStmt * swtch = new SwitchStmt(
+                        noLabels,
+                        result,
+                        std::list<Statement *>()
+                );
+                unsigned long i = 0;
+                for( auto & clause : waitfor->clauses ) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_ulong( i++ ) ),
+                                        {
+                                                clause.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->timeout.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -2 ) ),
+                                        {
+                                                waitfor->timeout.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->orelse.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -1 ) ),
+                                        {
+                                                waitfor->orelse.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                stmt->push_back( swtch );
+        }
 };

src/GenPoly/Box.cc

-              r201aeb9
+              rd67cdb7
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
-#include "DeclMutator.h"                 // for DeclMutator
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
 …
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 …
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                class BoxPass {
+                protected:
+                        BoxPass() : scopeTyVars( TypeDecl::Data{} ) {}
+                        TyVarMap scopeTyVars;
+                };
                 /// Adds layout-generation functions to polymorphic types
                 class LayoutFunctionBuilder final : public DeclMutator {
                         unsigned int functionNesting;  // current level of nested functions
+                class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
+                        unsigned int functionNesting = 0;  // current level of nested functions
                 public:
+                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
+                        using DeclMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        void previsit( FunctionDecl *functionDecl );
+                        void previsit( StructDecl *structDecl );
+                        void previsit( UnionDecl *unionDecl );
                 };
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 final : public PolyMutator {
+                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
                   public:
                         Pass1();
+                        using PolyMutator::mutate;
+                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
+                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
+                        virtual Expression *mutate( UntypedExpr *expr ) override;
+                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
+                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
+                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type * mutate( FunctionType *functionType ) override;
+                        virtual void doBeginScope() override;
+                        virtual void doEndScope() override;
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( CommaExpr * commaExpr );
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        Expression * postmutate( UntypedExpr *expr );
+                        void premutate( AddressExpr * addrExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                        void premutate( ReturnStmt * returnStmt );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * functionType );
+                        void beginScope();
+                        void endScope();
                   private:
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
 …
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
+                class Pass2 final : public PolyMutator {
+                  public:
+                        template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl );
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
+                        virtual TraitDecl *mutate( TraitDecl *unionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                struct Pass2 final : public BoxPass, public WithGuards {
+                        void handleAggDecl();
+                        DeclarationWithType * postmutate( FunctionDecl *functionDecl );
+                        void premutate( StructDecl *structDecl );
+                        void premutate( UnionDecl *unionDecl );
+                        void premutate( TraitDecl *unionDecl );
+                        void premutate( TypeDecl *typeDecl );
+                        void premutate( PointerType *pointerType );
+                        void premutate( FunctionType *funcType );
                   private:
 …
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
                 class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
                         PolyGenericCalculator();
 …
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
-                        TyVarMap scopeTyVars;
                 };
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                class Pass3 final : public PolyMutator {
+                  public:
+                struct Pass3 final : public BoxPass, public WithGuards {
                         template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        using PolyMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                  private:
+                        void handleDecl( DeclClass * decl, Type * type );
+                        void premutate( ObjectDecl * objectDecl );
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypedefDecl * typedefDecl );
+                        void premutate( StructDecl * structDecl );
+                        void premutate( UnionDecl * unionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * funcType );
                 };
         } // anonymous namespace
 …
         void box( std::list< Declaration *>& translationUnit ) {
                 LayoutFunctionBuilder layoutBuilder;
                 Pass1 pass1;
                 Pass2 pass2;
+                PassVisitor<LayoutFunctionBuilder> layoutBuilder;
+                PassVisitor<Pass1> pass1;
+                PassVisitor<Pass2> pass2;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
                 Pass3 pass3;
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
+                PassVisitor<Pass3> pass3;
+                acceptAll( translationUnit, layoutBuilder );
+                mutateAll( translationUnit, pass1 );
+                mutateAll( translationUnit, pass2 );
                 mutateAll( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
+                mutateAll( translationUnit, pass3 );
+        }
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
+        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->get_functionType(), *visitor );
                 ++functionNesting;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->get_statements(), *visitor );
                 --functionNesting;
-                return functionDecl;
+        }
 …
+        }
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
+        void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
+                if ( structDecl->get_members().empty() ) return structDecl;
+                visit_children = false;
+                if ( structDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
                 if ( otypeParams.empty() ) return structDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return structDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
+        void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
+                if ( unionDecl->get_members().empty() ) return unionDecl;
+                visit_children = false;
+                if ( unionDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
                 if ( otypeParams.empty() ) return unionDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return unionDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
 …
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
+                void Pass1::premutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
+                                doBeginScope();
+                                scopeTyVars.beginScope();
+                                DeclarationWithType *oldRetval = retval;
+                                GuardScope( scopeTyVars );
+                                GuardValue( retval );
                                 // process polymorphic return value
                                 retval = nullptr;
+                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
+                                        retval = functionDecl->get_functionType()->get_returnVals().front();
+                                FunctionType *functionType = functionDecl->type;
+                                if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) {
+                                        retval = functionType->returnVals.front();
                                         // give names to unnamed return values
                                         if ( retval->get_name() == "" ) {
                                                 retval->set_name( "_retparm" );
                                                 retval->set_linkage( LinkageSpec::C );
+                                        if ( retval->name == "" ) {
+                                                retval->name = "_retparm";
+                                                retval->linkage = LinkageSpec::C;
                                         } // if
                                 } // if
+                                FunctionType *functionType = functionDecl->get_functionType();
+                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+                                makeTyVarMap( functionType, scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->parameters;
                                 std::list< FunctionType *> functions;
                                 for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                         for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
+                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
 …
                                         } // if
                                 } // for
-                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-                                scopeTyVars.endScope();
-                                retval = oldRetval;
-                                doEndScope();
                                 // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
+                        return functionDecl;
+                }
+                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
+                }
+                void Pass1::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Expression *Pass1::mutate( CommaExpr *commaExpr ) {
+                }
+                void Pass1::premutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
 …
+                                }
+                        }
-                        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
-                        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
-                        return commaExpr;
+                }
-                Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
-                        condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
-                        condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
-                        condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
-                        return condExpr;
+                }
 …
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
+                }
 …
                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
                                         newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
                                         assign->get_args().push_back( new VariableExpr( newObj ) );
                                         assign->get_args().push_back( arg );
                                         stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
                                         arg = new AddressExpr( new VariableExpr( newObj ) );
                                 } // if
 …
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
                                                 stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
                                         assert( adapter != adapters.end() );
 …
+                }
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
+                Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 …
                         // }
                         // std::cerr << "\n";
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+                        assert( appExpr->get_function()->has_result() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
+                        assert( appExpr->function->result );
+                        FunctionType * function = getFunctionType( appExpr->function->result );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
+                }
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
                         if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                        if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
+                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
                                         if ( name->get_name() == "*?" ) {
                                                 Expression *ret = expr->get_args().front();
                                                 expr->get_args().clear();
+                                                Expression *ret = expr->args.front();
+                                                expr->args.clear();
                                                 delete expr;
                                                 return ret->acceptMutator( *this );
+                                                return ret;
                                         } // if
                                 } // if
                         } // if
+                        return PolyMutator::mutate( expr );
+                }
+                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
+                        return expr;
+                }
+                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
+                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor );
                         // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
 …
+                }
+                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->get_expr() ) {
+                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                delete returnStmt->get_expr();
+                                returnStmt->set_expr( 0 );
+                        } else {
+                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
+                void Pass1::premutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->expr ) {
+                                assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
+                                delete returnStmt->expr;
+                                returnStmt->expr = nullptr;
                         } // if
+                        return returnStmt;
+                }
+                Type * Pass1::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass1::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( FunctionType *functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
+                        Type *ret = Mutator::mutate( functionType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                void Pass1::doBeginScope() {
+                }
+                void Pass1::beginScope() {
                         adapters.beginScope();
+                }
                 void Pass1::doEndScope() {
+                void Pass1::endScope() {
                         adapters.endScope();
+                }
 …
+                }
+                template< typename DeclClass >
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
+                        return ret;
+                }
+                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
+                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+                DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
 …
+                }
+                ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl );
+                }
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
+                void Pass2::premutate( StructDecl * ) {
                         // prevent tyVars from leaking into containing scope
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( UnionDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TraitDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        if ( typeDecl->get_base() ) {
+                                return handleDecl( typeDecl );
+                        } else {
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
+                        }
+                }
+                TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl );
+                }
+                Type * Pass2::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Parent::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type *Pass2::mutate( FunctionType *funcType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( FunctionType *funcType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( funcType, scopeTyVars );
 …
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-//      *assert = (*assert)->acceptMutator( *this );
                                         // assertion parameters may not be used in body, pass along with unused attribute.
                                         (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
 …
+                                                }
+                                        }
                                         seenTypes.insert( typeName );
+                                }
 …
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );
-                        mutateAll( funcType->get_returnVals(), *this );
-                        mutateAll( funcType->get_parameters(), *this );
-                        scopeTyVars.endScope();
-                        return funcType;
+                }
 …
                 PolyGenericCalculator::PolyGenericCalculator()
                         : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
 …
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
                         scopeTyVars.beginScope();
+                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( type, scopeTyVars );
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
-                        // ScrubTyVars::scrub( decl, scopeTyVars );
                         ScrubTyVars::scrubAll( decl );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+                DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) {
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
+                }
+                TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                }
+                void Pass3::premutate( ObjectDecl * objectDecl ) {
+                        handleDecl( objectDecl, objectDecl->type );
+                }
+                void Pass3::premutate( FunctionDecl * functionDecl ) {
+                        handleDecl( functionDecl, functionDecl->type );
+                }
+                void Pass3::premutate( TypedefDecl * typedefDecl ) {
+                        handleDecl( typedefDecl, typedefDecl->base );
+                }
                 /// Strips the members from a generic aggregate
                 void stripGenericMembers(AggregateDecl* decl) {
                         if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
                 Declaration *Pass3::mutate( StructDecl *structDecl ) {
+                void stripGenericMembers(AggregateDecl * decl) {
+                        if ( ! decl->parameters.empty() ) decl->members.clear();
+                }
+                void Pass3::premutate( StructDecl * structDecl ) {
                         stripGenericMembers( structDecl );
+                        return structDecl;
+                }
+                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
+                }
+                void Pass3::premutate( UnionDecl * unionDecl ) {
                         stripGenericMembers( unionDecl );
+                        return unionDecl;
+                }
+                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
+//   Initializer *init = 0;
+//   std::list< Expression *> designators;
+//   addToTyVarMap( typeDecl, scopeTyVars );
+//   if ( typeDecl->get_base() ) {
+//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+//   }
+//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+                }
+                void Pass3::premutate( TypeDecl * typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Type * Pass3::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( PointerType * pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass3::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( FunctionType * functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
-                        Type *ret = Mutator::mutate( functionType );
-                        scopeTyVars.endScope();
-                        return ret;
+                }
         } // anonymous namespace

src/GenPoly/Specialize.cc

-              r201aeb9
+              rd67cdb7
 #include <utility>                       // for pair
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 …
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
 #include "Parser/LinkageSpec.h"          // for C
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
 …
 namespace GenPoly {
+        class Specialize final : public PolyMutator {
+          public:
+                using PolyMutator::mutate;
+                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+                virtual Expression * mutate( AddressExpr *castExpr ) override;
+                virtual Expression * mutate( CastExpr *castExpr ) override;
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
+        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+                Expression * postmutate( ApplicationExpr *applicationExpr );
+                Expression * postmutate( AddressExpr *castExpr );
+                Expression * postmutate( CastExpr *castExpr );
                 void handleExplicitParams( ApplicationExpr *appExpr );
 …
+        }
         struct EnvTrimmer : public Visitor {
+        struct EnvTrimmer {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 virtual void visit( TypeDecl * tyDecl ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
                         if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
                                 newEnv->add( tyDecl->get_name(), t );
+                        if ( Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        }
+                }
 …
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
                         EnvTrimmer trimmer( env, newEnv );
+                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
 …
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
                 // save stmtsToAdd in oldStmts
+                // save stmtsToAddBefore in oldStmts
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
                 mutate( appExpr );
+                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
+                appExpr->acceptMutator( *visitor );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
                 thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
                 // restore oldStmts into stmtsToAdd
                 stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
+                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
+                // restore oldStmts into stmtsToAddBefore
+                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
                 if ( funType->get_returnVals().empty() ) {
+                if ( funType->returnVals.empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
                 thunkFunc->get_statements()->get_kids().push_back( appStmt );
+                thunkFunc->statements->kids.push_back( appStmt );
                 // add thunk definition to queue of statements to add
                 stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
 …
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
                 assert( appExpr->get_function()->has_result() );
                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( appExpr->function->result );
+                FunctionType *function = getFunctionType( appExpr->function->result );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
+                appExpr->get_function()->acceptMutator( *this );
+                mutateAll( appExpr->get_args(), *this );
+                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
 …
+        }
+        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
+                addrExpr->get_arg()->acceptMutator( *this );
+                assert( addrExpr->has_result() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
+                assert( addrExpr->result );
+                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
                 return addrExpr;
+        }
+        Expression * Specialize::mutate( CastExpr *castExpr ) {
+                castExpr->get_arg()->acceptMutator( *this );
+                if ( castExpr->get_result()->isVoid() ) {
+        Expression * Specialize::postmutate( CastExpr *castExpr ) {
+                if ( castExpr->result->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
+                }
                 Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
+                if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
 …
+        }
-        // Removing these for now. Richard put these in for some reason, but it's not clear why.
-        // In particular, copy constructors produce a comma expression, and with this code the parts
-        // of that comma expression are not specialized, which causes problems.
-        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
-        //      return logicalExpr;
-        // }
-        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
-        //      return condExpr;
-        // }
-        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
-        //      return commaExpr;
-        // }
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
                 Specialize spec;
+                PassVisitor<Specialize> spec;
                 mutateAll( translationUnit, spec );
+        }

src/GenPoly/module.mk

-              r201aeb9
+              rd67cdb7
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
 SRC += GenPoly/Box.cc \
        GenPoly/GenPoly.cc \
-       GenPoly/PolyMutator.cc \
        GenPoly/ScrubTyVars.cc \
        GenPoly/Lvalue.cc \
 …
        GenPoly/CopyParams.cc \
        GenPoly/FindFunction.cc \
-       GenPoly/DeclMutator.cc \
        GenPoly/InstantiateGeneric.cc

src/InitTweak/FixInit.cc

-              r201aeb9
+              rd67cdb7
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
-#include "GenPoly/DeclMutator.h"       // for DeclMutator
 #include "GenPoly/GenPoly.h"           // for getFunctionType
-#include "GenPoly/PolyMutator.h"       // for PolyMutator
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
 …
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/AddStmtVisitor.h"    // for AddStmtVisitor
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
 …
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
-#include "Tuples/Tuples.h"             // for isTtype
 bool ctordtorp = false; // print all debug
 …
                 };
                 class FixCopyCtors final : public GenPoly::PolyMutator {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
 …
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void premutate( StmtExpr * stmtExpr );
+                        void premutate( UniqueExpr * unqExpr );
                         UnqCount & unqCount;
 …
                 };
+                class FixCtorExprs final : public GenPoly::DeclMutator {
+                  public:
+                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
+                        using GenPoly::DeclMutator::mutate;
+                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
+                        Expression * postmutate( ConstructorExpr * ctorExpr );
                 };
         } // namespace
 …
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
                         FixCopyCtors fixer( unqCount );
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         mutateAll( translationUnit, fixer );
+                }
 …
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
                         FixCtorExprs fixer;
                         fixer.mutateDeclarationList( translationUnit );
+                        PassVisitor<FixCtorExprs> fixer;
+                        mutateAll( translationUnit, fixer );
+                }
 …
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
+                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
                                         if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
 …
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
 …
                         result = result->clone();
                         env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
 …
                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
+                        }
+                        // set a unique name for the temporary once it's certain the call is necessary
+                        tmp->name = tempNamer.newName();
                         // replace argument to function call with temporary
 …
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
+                                }
 …
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
 …
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
                                 unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
+                        }
 …
+                }
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
-                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
 …
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 …
                         } // for
-                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 …
+                }
                 Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
                         //   f(g());
+                        //   g(f());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
+                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
+                        // to the outer context, rather than inside of the statement expression.
+                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *this );
+                                stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
 …
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
+                                assert( ! stmts.empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
                                 body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
 …
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
                         return stmtExpr;
+                }
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                }
+                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
+                        visit_children = false;
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
 …
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
+                                }
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        FixCopyCtors fixer( unqCount );
+                                return;
+                        }
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
+                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
+                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
+                        }
+                        return;
+                }
 …
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
                                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
 …
                                         // skip non-DWT members
                                         if ( ! field ) continue;
+                                        // skip non-constructable members
+                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
 …
+                }
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
+                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
 …
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
                         addDeclaration( tmp );
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
 …
                         delete ctorExpr;
+                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
                         firstArg = new VariableExpr( tmp );
+                        // resolve assignment and dispose of new env
+                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
+                        delete resolvedAssign->env;
+                        resolvedAssign->env = nullptr;
+                        delete assign;
                         // for constructor expr:
 …
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
                         CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/InitTweak/GenInit.cc

-              r201aeb9
+              rd67cdb7
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
 …
         };
         struct CtorDtor : public WithGuards, public WithShortCircuiting  {
+        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
 …
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
+                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
+                void previsit( AggregateDecl * ) { visit_children = false; }
+                void previsit( NamedTypeDecl * ) { visit_children = false; }
+                void previsit( FunctionType * ) { visit_children = false; }
                 void previsit( CompoundStmt * compoundStmt );
 …
         };
+        class HoistArrayDimension final : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
 …
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
+          private:
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void premutate( ObjectDecl * objectDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+                void premutate( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
+                void premutate( AggregateDecl * ) { visit_children = false; }
+                void premutate( NamedTypeDecl * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
                 void hoist( Type * type );
 …
         void genInit( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer::makeReturnTemp( translationUnit );
+                fixReturnStatements( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
+        }
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
+        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
 …
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
 …
                 GuardValue( funcName );
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
+                ftype = functionDecl->type;
+                funcName = functionDecl->name;
+        }
 …
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+                PassVisitor<HoistArrayDimension> hoister;
+                mutateAll( translationUnit, hoister );
+        }
+        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
+                GuardValue( storageClasses );
                 storageClasses = objectDecl->get_storageClasses();
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
+        }
+        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
                 hoist( objectDecl->get_type() );
                 return temp;
+                return objectDecl;
+        }
 …
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
                         addDeclaration( arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
                         hoist( arrayType->get_base() );
 …
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc( inFunction );
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                return decl;
+        void HoistArrayDimension::premutate( FunctionDecl * ) {
+                GuardValue( inFunction );
+        }
 …
         bool CtorDtor::isManaged( Type * type ) const {
                 // at least for now, references are never constructed
+                // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
 …
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
                         // tuple is also managed if any of its components are managed
                         if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
+                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
+                        }
 …
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
 …
+                }
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+                maybeAccept( functionDecl->get_statements(), *visitor );
+        }
 …
+        }
         void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
+        void CtorDtor::previsit( CompoundStmt * ) {
                 GuardScope( managedTypes );
+        }

src/InitTweak/GenInit.h

-              r201aeb9
+              rd67cdb7
         void genInit( std::list< Declaration * > & translationUnit );
+  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        /// Converts return statements into copy constructor calls on the hidden return variable
+        void fixReturnStatements( std::list< Declaration * > & translationUnit );
+        /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

-              r201aeb9
+              rd67cdb7
-#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
 …
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
+#include "Tuples/Tuples.h"         // for Tuples::isTtype
 class UntypedValofExpr;
 …
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
                         *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
 …
         // To accomplish this, generate switch statement, consuming all of expander's elements
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return NULL;
+                if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
                         delete block;
                         return NULL;
+                        return nullptr;
                 } else {
                         init = NULL; // init was consumed in creating the list init
+                        init = nullptr; // init was consumed in creating the list init
                         return block;
+                }
+        }
         Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
+        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+                return nullptr;
+        }
 …
+        }
+        bool tryConstruct( ObjectDecl * objDecl ) {
+        bool tryConstruct( DeclarationWithType * dwt ) {
+                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
+                        (objDecl->get_init() == NULL ||
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern;
+                        (objDecl->get_init() == nullptr ||
+                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern
+                        && isConstructable( objDecl->type );
+        }
+        bool isConstructable( Type * type ) {
+                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
 …
                 collectCtorDtorCalls( stmt, matches );
                 assert( matches.size() <= 1 );
                 return matches.size() == 1 ? matches.front() : NULL;
+                return matches.size() == 1 ? matches.front() : nullptr;
+        }
 …
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
                 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
                 if ( ! appExpr ) return NULL;
+                if ( ! appExpr ) return nullptr;
                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
                 assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
                 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
                 // will call all member dtors, and some members may have a user defined dtor.
                 return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
+                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
+        }
 …
                         return refType->get_base();
                 } else {
                         return NULL;
+                        return nullptr;
+                }
+        }
 …
         Type * isPointerType( Type * type ) {
                 if ( getPointerBase( type ) ) return type;
                 else return NULL;
+                else return nullptr;
+        }

src/InitTweak/InitTweak.h

-              r201aeb9
+              rd67cdb7
         std::list< Expression * > makeInitList( Initializer * init );
+        /// True if the resolver should try to construct objDecl
+        bool tryConstruct( ObjectDecl * objDecl );
+        /// True if the resolver should try to construct dwt
+        bool tryConstruct( DeclarationWithType * dwt );
+        /// True if the type can have a user-defined constructor
+        bool isConstructable( Type * t );
         /// True if the Initializer contains designations

src/Makefile.in

-              r201aeb9
+              rd67cdb7
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \
 …
         GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
         InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
 …
         SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
 …
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
+        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
+        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
+        GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
+        GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \
+        GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
+        GenPoly/Specialize.cc GenPoly/CopyParams.cc \
+        GenPoly/FindFunction.cc GenPoly/InstantiateGeneric.cc \
         InitTweak/GenInit.cc InitTweak/FixInit.cc \
         InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
 …
         SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Virtual/ExpandCasts.cc
+        SynTree/TypeSubstitution.cc SynTree/Attribute.cc \
+        SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc Tuples/Explode.cc \
+        Virtual/ExpandCasts.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
 …
 GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi`
-GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi`
-GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi`
-SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
 SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc

src/Parser/StatementNode.cc

-              r201aeb9
+              rd67cdb7
                 target,
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
         delete targetExpr;
         node->clauses.push_back( WaitForStmt::Clause{
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
                 node->timeout.time      = maybeMoveBuild<Expression>( timeout );
                 node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
                 node->timeout.condition = maybeMoveBuild<Expression>( when    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
         else {
                 node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
                 node->orelse.condition  = maybeMoveBuild<Expression>( when    );
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
 …
         node->timeout.time      = maybeMoveBuild<Expression>( timeout );
         node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
         node->timeout.condition = maybeMoveBuild<Expression>( when    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
         node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
         node->orelse.condition = maybeMoveBuild<Expression>( else_when );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
         return node;
+}
-// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
-//       return WaitForStmt::Clause{
-//       };
-// }
 Statement *build_compound( StatementNode *first ) {

src/Parser/parserutility.cc

r201aeb9	rd67cdb7
29	29
30	30	Expression notZeroExpr( Expression orig ) {
	31	if( !orig ) return nullptr;
31	32	UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
32	33	comparison->get_args().push_back( orig );

src/ResolvExpr/AlternativeFinder.cc

-              r201aeb9
+              rd67cdb7
                         expr->get_result()->accept( global_renamer );
+                }
-                void referenceToRvalueConversion( Expression *& expr ) {
-                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
-                                // cast away reference from expr
-                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
         } // namespace
+        void referenceToRvalueConversion( Expression *& expr ) {
+                if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        // cast away reference from expr
+                        expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                }
+        }
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/AlternativeFinder.h

-              r201aeb9
+              rd67cdb7
                 const SymTab::Indexer &get_indexer() const { return indexer; }
                 const TypeEnvironment &get_environ() const { return env; }
+                /// Runs a new alternative finder on each element in [begin, end)
+                /// and writes each alternative finder to out.
+                template< typename InputIterator, typename OutputIterator >
+                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
                 virtual void visit( ApplicationExpr *applicationExpr );
 …
                 virtual void visit( StmtExpr *stmtExpr );
                 virtual void visit( UntypedInitExpr *initExpr );
-                /// Runs a new alternative finder on each element in [begin, end)
-                /// and writes each alternative finder to out.
-                template< typename InputIterator, typename OutputIterator >
-                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
                 /// Adds alternatives for anonymous members
 …
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
+        void referenceToRvalueConversion( Expression *& expr );
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/Resolver.cc

-              r201aeb9
+              rd67cdb7
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 using namespace std;
 …
                 void previsit( ThrowStmt *throwStmt );
                 void previsit( CatchStmt *catchStmt );
+                void previsit( WaitForStmt * stmt );
                 void previsit( SingleInit *singleInit );
 …
                 PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
+        }
+        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+                PassVisitor<Resolver> resolver( indexer );
+                maybeAccept( decl, resolver );
+        }
 …
+        }
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cout << "untyped expr is ";
+                        untyped->print( std::cout );
+                        std::cout << std::endl << "alternatives are:";
+                        for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
+                                i->print( std::cout );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env );
+                return newExpr;
+        }
         namespace {
-                Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                        Alternative &choice = finder.get_alternatives().front();
-                        Expression *newExpr = choice.expr->clone();
-                        finishExpr( newExpr, choice.env );
-                        return newExpr;
+                }
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
 …
+        }
+        inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( expr, indexer );
+                delete expr;
+                expr = newExpr;
+        }
+        inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
+                if( !expr ) return;
+                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
+                delete expr;
+                expr = newExpr;
+        }
+        template< typename iterator_t >
+        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
+                while( it != end && !(*it)->get_type()->get_mutex() ) {
+                        it++;
+                }
+                return it != end;
+        }
+        void Resolver::previsit( WaitForStmt * stmt ) {
+                visit_children = false;
+                // Resolve all clauses first
+                for( auto& clause : stmt->clauses ) {
+                        TypeEnvironment env;
+                        AlternativeFinder funcFinder( indexer, env );
+                        // Find all alternatives for a function in canonical form
+                        funcFinder.findWithAdjustment( clause.target.function );
+                        if ( funcFinder.get_alternatives().empty() ) {
+                                stringstream ss;
+                                ss << "Use of undeclared indentifier '";
+                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
+                                ss << "' in call to waitfor";
+                                throw SemanticError( ss.str() );
+                        }
+                        // Find all alternatives for all arguments in canonical form
+                        std::list< AlternativeFinder > argAlternatives;
+                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
+                        // List all combinations of arguments
+                        std::list< AltList > possibilities;
+                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+                        AltList                func_candidates;
+                        std::vector< AltList > args_candidates;
+                        // For every possible function :
+                        //      try matching the arguments to the parameters
+                        //      not the other way around because we have more arguments than parameters
+                        SemanticError errors;
+                        for ( Alternative & func : funcFinder.get_alternatives() ) {
+                                try {
+                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
+                                        if( !pointer ) {
+                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                        }
+                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                        if( !function ) {
+                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                        }
+                                        {
+                                                auto param     = function->parameters.begin();
+                                                auto param_end = function->parameters.end();
+                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                }
+                                        }
+                                        Alternative newFunc( func );
+                                        // Strip reference from function
+                                        referenceToRvalueConversion( newFunc.expr );
+                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
+                                        for ( auto & argsList : possibilities ) {
+                                                try {
+                                                        // Declare data structures need for resolution
+                                                        OpenVarSet openVars;
+                                                        AssertionSet resultNeed, resultHave;
+                                                        TypeEnvironment resultEnv;
+                                                        // Load type variables from arguemnts into one shared space
+                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
+                                                        // Make sure we don't widen any existing bindings
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+                                                        // Find any unbound type variables
+                                                        resultEnv.extractOpenVars( openVars );
+                                                        auto param     = function->parameters.begin();
+                                                        auto param_end = function->parameters.end();
+                                                        // For every arguments of its set, check if it matches one of the parameter
+                                                        // The order is important
+                                                        for( auto & arg : argsList ) {
+                                                                // Ignore non-mutex arguments
+                                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                                        // We ran out of parameters but still have arguments
+                                                                        // this function doesn't match
+                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                }
+                                                                // Check if the argument matches the parameter type in the current scope
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                        // Type doesn't match
+                                                                        stringstream ss;
+                                                                        ss << "candidate function not viable: no known convertion from '";
+                                                                        arg.expr->get_result()->print( ss );
+                                                                        ss << "' to '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "'\n";
+                                                                        throw SemanticError(ss.str(), function);
+                                                                }
+                                                                param++;
+                                                        }
+                                                        // All arguments match !
+                                                        // Check if parameters are missing
+                                                        if( advance_to_mutex( param, param_end ) ) {
+                                                                // We ran out of arguments but still have parameters left
+                                                                // this function doesn't match
+                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                        }
+                                                        // All parameters match !
+                                                        // Finish the expressions to tie in the proper environments
+                                                        finishExpr( newFunc.expr, resultEnv );
+                                                        for( Alternative & alt : argsList ) {
+                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
+                                                        // This is a match store it and save it for later
+                                                        func_candidates.push_back( newFunc );
+                                                        args_candidates.push_back( argsList );
+                                                }
+                                                catch( SemanticError &e ) {
+                                                        errors.append( e );
+                                                }
+                                        }
+                                }
+                                catch( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+                        // Make sure we got the right number of arguments
+                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+                        // Swap the results from the alternative with the unresolved values.
+                        // Alternatives will handle deletion on destruction
+                        std::swap( clause.target.function, func_candidates.front().expr );
+                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
+                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( clause.condition, this->indexer );
+                        clause.statement->accept( *visitor );
+                }
+                if( stmt->timeout.statement ) {
+                        // Resolve the timeout as an size_t for now
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        resolveAsIf  ( stmt->timeout.condition, this->indexer );
+                        stmt->timeout.statement->accept( *visitor );
+                }
+                if( stmt->orelse.statement ) {
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        resolveAsIf( stmt->orelse.condition, this->indexer );
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
         template< typename T >
         bool isCharType( T t ) {

src/ResolvExpr/Resolver.h

-              r201aeb9
+              rd67cdb7
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
+        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

-              r201aeb9
+              rd67cdb7
                 for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
                         for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
 ///       std::cout << "adding " << *theVar;
+///       std::cerr << "adding " << *theVar;
                                 if ( theClass->type ) {
 ///         std::cout << " bound to ";
 ///         theClass->type->print( std::cout );
 ///         std::cout << std::endl;
+///         std::cerr << " bound to ";
+///         theClass->type->print( std::cerr );
+///         std::cerr << std::endl;
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
                                         TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
 ///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
+///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
                                         delete newTypeInst;

src/SymTab/Autogen.cc

-              r201aeb9
+              rd67cdb7
 #include "Autogen.h"
-#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
 …
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
+#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "InitTweak/GenInit.h"     // for fixReturnStatements
+#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
 …
         };
+        class AutogenerateRoutines final : public Visitor {
+            template< typename Visitor >
+            friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+            template< typename Visitor >
+            friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
+          public:
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+                typedef Visitor Parent;
+                using Parent::visit;
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
                 AutogenerateRoutines();
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                void previsit( EnumDecl * enumDecl );
+                void previsit( StructDecl * structDecl );
+                void previsit( UnionDecl * structDecl );
+                void previsit( TypeDecl * typeDecl );
+                void previsit( TraitDecl * traitDecl );
+                void previsit( FunctionDecl * functionDecl );
+                void previsit( FunctionType * ftype );
+                void previsit( PointerType * ptype );
+                void previsit( CompoundStmt * compoundStmt );
           private:
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                std::set< std::string > structsDone;
+                GenPoly::ScopedSet< std::string > structsDone;
                 unsigned int functionNesting = 0;     // current level of nested functions
                 /// Note: the following maps could be ScopedSets, but it should be easier to work
 …
         /// generates routines for tuple types.
+        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
+        /// or anything we currently have that supports adding new declarations for visitors
+        class AutogenTupleRoutines : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+                virtual Type * mutate( TupleType *tupleType );
+                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
+        struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
+                void previsit( FunctionDecl *functionDecl );
+                void postvisit( TupleType *tupleType );
+                void previsit( CompoundStmt *compoundStmt );
           private:
 …
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
                 AutogenerateRoutines generator;
                 acceptAndAdd( translationUnit, generator );
+                PassVisitor<AutogenerateRoutines> generator;
+                acceptAll( translationUnit, generator );
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
                 // AutogenTupleRoutines tupleGenerator;
                 // tupleGenerator.mutateDeclarationList( translationUnit );
+                // acceptAll( translationUnit, tupleGenerator );
+        }
         bool isUnnamedBitfield( ObjectDecl * obj ) {
                 return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
+                return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
+        }
 …
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
                 decl->set_statements( NULL );
+                decl->set_statements( nullptr );
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
 …
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
                                 ObjectDecl * srcParam = NULL;
+                                ObjectDecl * srcParam = nullptr;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
 …
                                 assert( dstParam );
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
 …
                                 } else {
                                         // no matching parameter, initialize field with default ctor
                                         makeStructMemberOp( dstParam, NULL, field, func );
+                                        makeStructMemberOp( dstParam, nullptr, field, func );
+                                }
+                        }
 …
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
                         return;
+                }
                 // Make function polymorphic in same parameters as generic struct, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
                 // generate each of the functions based on the supplied FuncData objects
 …
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
+                data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
+                data.push_back( FuncData( "?{}", genCopyType, copyable ) );
+                data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
+                data.push_back( FuncData( "?=?", genAssignType, assignable ) );
+        }
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+                data.emplace_back( "?{}", genDefaultType, constructable );
+                data.emplace_back( "?{}", genCopyType, copyable );
+                data.emplace_back( "^?{}", genDefaultType, destructable );
+                data.emplace_back( "?=?", genAssignType, assignable );
+        }
+        void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
+                visit_children = false;
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
 …
+        }
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
+        void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
+                visit_children = false;
+                if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->name );
+                        for ( TypeDecl * typeDecl : structDecl->parameters ) {
                                 // need to visit assertions so that they are added to the appropriate maps
                                 acceptAll( typeDecl->get_assertions(), *this );
                                 structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                                acceptAll( typeDecl->assertions, *visitor );
+                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
+                        }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
                         structsDone.insert( structDecl->get_name() );
+                        structsDone.insert( structDecl->name );
                 } // if
+        }
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
+                visit_children = false;
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
 …
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+                visit_children = false;
                 if ( ! typeDecl->base ) return;
 …
+        }
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+        void AutogenerateRoutines::visit( FunctionType *) {
+        void AutogenerateRoutines::previsit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
+        }
+        void AutogenerateRoutines::visit( PointerType *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
+        }
+        void AutogenerateRoutines::visit( TraitDecl *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( TraitDecl * ) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
+        }
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+                visit_children = false;
                 // record the existence of this function as appropriate
                 insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
 …
                 insert( functionDecl, destructable, InitTweak::isDestructor );
                 maybeAccept( functionDecl->get_functionType(), *this );
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 maybeAccept( functionDecl->get_statements(), *this );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+        }
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                constructable.beginScope();
+                assignable.beginScope();
+                copyable.beginScope();
+                destructable.beginScope();
+                visitStatement( compoundStmt );
+                constructable.endScope();
+                assignable.endScope();
+                copyable.endScope();
+                destructable.endScope();
+        }
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
+        void AutogenerateRoutines::previsit( CompoundStmt * ) {
+                GuardScope( constructable );
+                GuardScope( assignable );
+                GuardScope( copyable );
+                GuardScope( destructable );
+                GuardScope( structsDone );
+        }
 …
+        }
+        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
+                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
+        void AutogenTupleRoutines::postvisit( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
                 if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
+                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return;
                 seenTuples.insert( mangleName );
 …
                 makeTupleFunctionBody( dtorDecl );
+                addDeclaration( ctorDecl );
+                addDeclaration( copyCtorDecl );
+                addDeclaration( dtorDecl );
+                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
+                return tupleType;
+        }
+        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+                declsToAddBefore.push_back( ctorDecl );
+                declsToAddBefore.push_back( copyCtorDecl );
+                declsToAddBefore.push_back( dtorDecl );
+                declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+        void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+                return functionDecl;
+        }
+        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
+                seenTuples.beginScope();
+                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
+                seenTuples.endScope();
+                return compoundStmt;
+        }
+        void AutogenTupleRoutines::previsit( CompoundStmt * ) {
+                GuardScope( seenTuples );
+        }
 } // SymTab

src/SymTab/FixFunction.cc

-              r201aeb9
+              rd67cdb7
         DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+                // can't delete function type because it may contain assertions, so transfer ownership to new object
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
                 functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
+                functionDecl->type = nullptr;
                 delete functionDecl;
                 return pointer;

src/SymTab/Indexer.cc

-              r201aeb9
+              rd67cdb7
 namespace SymTab {
-        struct NewScope {
-                NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
-                ~NewScope() { indexer.leaveScope(); }
-                SymTab::Indexer & indexer;
-        };
-        template< typename TreeType, typename VisitorType >
-        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
-                visitor.enterScope();
-                maybeAccept( tree, visitor );
-                visitor.leaveScope();
+        }
         typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
 …
+        }
         Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
         Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
         Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
                 that.tables = 0;
+        }

src/SymTab/Indexer.h

-              r201aeb9
+              rd67cdb7
         class Indexer {
           public:
                 explicit Indexer( bool useDebug = false );
+                explicit Indexer();
                 Indexer( const Indexer &that );
 …
                 void addTrait( TraitDecl *decl );
+                bool doDebug = false; ///< Display debugging trace?
           private:
                 struct Impl;
 …
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
-                bool doDebug;         ///< Display debugging trace?
                 /// Takes a new ref to a table (returns null if null)

src/SymTab/Mangler.cc

-              r201aeb9
+              rd67cdb7
 namespace SymTab {
         std::string Mangler::mangleType( Type *ty ) {
+        std::string Mangler::mangleType( Type * ty ) {
                 Mangler mangler( false, true );
                 maybeAccept( ty, mangler );
 …
+        }
         void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
 …
+        }
         void Mangler::visit( ObjectDecl *declaration ) {
+        void Mangler::visit( ObjectDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( FunctionDecl *declaration ) {
+        void Mangler::visit( FunctionDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( VoidType *voidType ) {
+        void Mangler::visit( VoidType * voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
+        }
         void Mangler::visit( BasicType *basicType ) {
+        void Mangler::visit( BasicType * basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
 …
+        }
         void Mangler::visit( PointerType *pointerType ) {
+        void Mangler::visit( PointerType * pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
 …
+        }
         void Mangler::visit( ArrayType *arrayType ) {
+        void Mangler::visit( ArrayType * arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
 …
+        }
         void Mangler::visit( ReferenceType *refType ) {
+        void Mangler::visit( ReferenceType * refType ) {
                 printQualifiers( refType );
                 mangleName << "R";
 …
+        }
         void Mangler::visit( FunctionType *functionType ) {
+        void Mangler::visit( FunctionType * functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
 …
+        }
         void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
 …
+        }
         void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
 …
+        }
         void Mangler::visit( StructInstType *aggregateUseType ) {
+        void Mangler::visit( StructInstType * aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
                 else mangleRef( aggregateUseType, "s" );
+        }
         void Mangler::visit( UnionInstType *aggregateUseType ) {
+        void Mangler::visit( UnionInstType * aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
                 else mangleRef( aggregateUseType, "u" );
+        }
         void Mangler::visit( EnumInstType *aggregateUseType ) {
+        void Mangler::visit( EnumInstType * aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
+        }
         void Mangler::visit( TypeInstType *typeInst ) {
+        void Mangler::visit( TypeInstType * typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
 …
+        }
         void Mangler::visit( TupleType *tupleType ) {
+        void Mangler::visit( TupleType * tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
                 acceptAll( tupleType->get_types(), *this );
+                acceptAll( tupleType->types, *this );
                 mangleName << "_";
+        }
         void Mangler::visit( VarArgsType *varArgsType ) {
+        void Mangler::visit( VarArgsType * varArgsType ) {
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
+        }
         void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Mangler::visit( ZeroType * ) {
                 mangleName << "Z";
+        }
         void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
+        void Mangler::visit( OneType * ) {
                 mangleName << "O";
+        }
         void Mangler::visit( TypeDecl *decl ) {
+        void Mangler::visit( TypeDecl * decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+        }
 …
+        }
         void Mangler::printQualifiers( Type *type ) {
+        void Mangler::printQualifiers( Type * type ) {
                 // skip if not including qualifiers
                 if ( typeMode ) return;
 …
                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
                                   case TypeDecl::Any:
 …
                                         assert( false );
                                 } // switch
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
                                         Mangler sub_mangler( mangleOverridable, typeMode );
                                         sub_mangler.nextVarNum = nextVarNum;
 …
                         mangleName << "V";
                 } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
 …
 //              } // if
                 if ( type->get_lvalue() ) {
+                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                         mangleName << "L";
                 } // if
+                }
                 if ( type->get_atomic() ) {
                         mangleName << "A";

src/SymTab/Validate.cc

-              r201aeb9
+              rd67cdb7
 #include "FixFunction.h"               // for FixFunction
 #include "Indexer.h"                   // for Indexer
+#include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
 #include "Parser/LinkageSpec.h"        // for C
 …
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
         struct ForallPointerDecay final {
                 void previsit( ObjectDecl *object );
                 void previsit( FunctionDecl *func );
+                void previsit( ObjectDecl * object );
+                void previsit( FunctionDecl * func );
         };
 …
         /// Fix up assertions - flattens assertion lists, removing all trait instances
         void forallFixer( Type * func ) {
                 for ( TypeDecl * type : func->get_forall() ) {
+        void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
+                for ( TypeDecl * type : forall ) {
                         std::list< DeclarationWithType * > asserts;
                         asserts.splice( asserts.end(), type->assertions );
 …
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.get_isVoid() ) {
                                         throw SemanticError( "invalid type void in assertion of function ", func );
+                                        throw SemanticError( "invalid type void in assertion of function ", node );
                                 } // if
                         } // for
 …
         void ForallPointerDecay::previsit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
                         forallFixer( pointer->get_base() );
+                forallFixer( object->type->forall, object );
+                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
+                        forallFixer( pointer->base->forall, object );
                 } // if
                 object->fixUniqueId();
 …
         void ForallPointerDecay::previsit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
+                forallFixer( func->type->forall, func );
                 func->fixUniqueId();
+        }

src/SynTree/BaseSyntaxNode.h

-              r201aeb9
+              rd67cdb7
         virtual void accept( Visitor & v ) = 0;
   virtual void print( std::ostream & os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
 };
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
 // Local Variables: //

src/SynTree/CompoundStmt.cc

-              r201aeb9
+              rd67cdb7
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+}
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
+}

src/SynTree/Constant.cc

-              r201aeb9
+              rd67cdb7
 Constant Constant::from_bool( bool b ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::Bool ), b ? "1" : "0" , (unsigned long long int)b );
+}
+Constant Constant::from_char( char c ) {
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
+}

src/SynTree/Constant.h

r201aeb9	rd67cdb7
40	40	/// generates a boolean constant of the given bool
41	41	static Constant from_bool( bool b );
	42	/// generates a char constant of the given char
	43	static Constant from_char( char c );
42	44	/// generates an integer constant of the given int
43	45	static Constant from_int( int i );

src/SynTree/Declaration.cc

-              r201aeb9
+              rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        if ( decl ){
-                decl->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {

src/SynTree/Declaration.h

-              r201aeb9
+              rd67cdb7
         void fixUniqueId( void );
         virtual Declaration *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Declaration *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
         virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
 …
         //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
         virtual DeclarationWithType *clone() const = 0;
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual DeclarationWithType *clone() const override = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
         virtual Type * get_type() const = 0;
 …
         virtual ~ObjectDecl();
         virtual Type * get_type() const { return type; }
         virtual void set_type(Type *newType) { type = newType; }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type *newType) override { type = newType; }
         Initializer *get_init() const { return init; }
 …
         static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
         virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         virtual ~FunctionDecl();
         Type * get_type() const { return type; }
         virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
         FunctionType * get_functionType() const { return type; }
 …
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         virtual std::string typeString() const = 0;
         virtual NamedTypeDecl *clone() const = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual NamedTypeDecl *clone() const override = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
 };
 …
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
         virtual std::string genTypeString() const;
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
 …
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
         virtual std::string typeString() const;
         virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual std::string typeString() const override;
+        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
 …
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
   protected:
         virtual std::string typeString() const = 0;
 …
         bool is_thread() { return kind == DeclarationNode::Thread; }
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
         virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
         virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         TraitDecl( const TraitDecl &other ) : Parent( other ) {}
         virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
+        virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+};
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );

src/SynTree/Expression.cc

-              r201aeb9
+              rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
-        if ( expr ) {
-                expr->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Expression.h

-              r201aeb9
+              rd67cdb7
 };
-std::ostream & operator<<( std::ostream & out, const Expression * expr );
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.cc

-              r201aeb9
+              rd67cdb7
+}
-std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
-        if ( init ) {
-                init->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
-std::ostream & operator<<( std::ostream & out, const Designation * des ) {
-        if ( des ) {
-                des->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.h

-              r201aeb9
+              rd67cdb7
         virtual Designation * clone() const { return new Designation( *this ); };
         virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         virtual Initializer *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
   private:
         bool maybeConstructed;
 …
         void set_value( Expression *newValue ) { value = newValue; }
         virtual SingleInit *clone() const { return new SingleInit( *this); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual SingleInit *clone() const override { return new SingleInit( *this); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         const_iterator end() const { return initializers.end(); }
         virtual ListInit *clone() const { return new ListInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ListInit *clone() const override { return new ListInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         Initializer * get_init() const { return init; }
         ConstructorInit *clone() const { return new ConstructorInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
 …
 };
-std::ostream & operator<<( std::ostream & out, const Initializer * init );
-std::ostream & operator<<( std::ostream & out, const Designation * des );
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.cc

-              r201aeb9
+              rd67cdb7
+}
 SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, std::list<Statement *> &statements ):
+SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
         Statement( labels ), condition( condition ), statements( statements ) {
+}
 …
+}
 CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
         Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != 0 )
 …
+}
-std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
-        if ( statement ) {
-                statement->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

-              r201aeb9
+              rd67cdb7
         virtual Statement *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
+        virtual void accept( Visitor &v ) override = 0;
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         CompoundStmt( std::list<Label> labels );
+        CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
 …
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
         virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         NullStmt( std::list<Label> labels );
         virtual NullStmt *clone() const { return new NullStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_elsePart( Statement *newValue ) { elsePart = newValue; }
         virtual IfStmt *clone() const { return new IfStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         std::list<Statement *> statements;
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
+        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
 …
         std::list<Statement *> & get_statements() { return statements; }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         std::list<Statement *> stmts;
         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
 …
         void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
         bool _isDefault;
 …
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
         virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_body( Statement *newValue ) { body = newValue; }
         virtual ForStmt *clone() const { return new ForStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         const char *get_typename() { return brType[ type ]; }
         virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
   private:
         static const char *brType[];
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_target( Expression * newTarget ) { target = newTarget; }
         virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
         virtual TryStmt *clone() const { return new TryStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_body( Statement *newValue ) { body = newValue; }
         virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_block( CompoundStmt *newValue ) { block = newValue; }
         virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         } orelse;
         virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_decl( Declaration *newValue ) { decl = newValue; }
         virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
 };
 …
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
+        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Statement * statement );
+        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const override;
+};
 // Local Variables: //

src/SynTree/Type.cc

-              r201aeb9
+              rd67cdb7
 const Type::Qualifiers noQualifiers;
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
-        if ( type ) {
-                type->print( out );
-        } else {
-                out << "nullptr";
-        } // if
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

-              r201aeb9
+              rd67cdb7
         VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         virtual unsigned size() const { return 0; };
         virtual bool isComplete() const { return false; }
         virtual VoidType *clone() const { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return 0; };
+        virtual bool isComplete() const override { return false; }
+        virtual VoidType *clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_kind( Kind newValue ) { kind = newValue; }
         virtual BasicType *clone() const { return new BasicType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual BasicType *clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
         bool isInteger() const;
 …
         bool is_array() const { return isStatic || isVarLen || dimension; }
         virtual bool isComplete() const { return ! isVarLen; }
         virtual PointerType *clone() const { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+        virtual PointerType *clone() const override { return new PointerType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_isStatic( bool newValue ) { isStatic = newValue; }
         virtual bool isComplete() const { return ! isVarLen; }
         virtual ArrayType *clone() const { return new ArrayType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_base( Type *newValue ) { base = newValue; }
         virtual int referenceDepth() const;
+        virtual int referenceDepth() const override;
         // Since reference types act like value types, their size is the size of the base.
         // This makes it simple to cast the empty tuple to a reference type, since casts that increase
         // the number of values are disallowed.
         virtual unsigned size() const { return base->size(); }
         virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return base->size(); }
+        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         bool isTtype() const;
         virtual FunctionType *clone() const { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_hoistType( bool newValue ) { hoistType = newValue; }
         virtual ReferenceToType *clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ReferenceToType *clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
 …
         std::list<TypeDecl*> * get_baseParameters();
         virtual bool isComplete() const;
+        virtual bool isComplete() const override;
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
         virtual StructInstType *clone() const { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         std::list< TypeDecl * > * get_baseParameters();
         virtual bool isComplete() const;
+        virtual bool isComplete() const override;
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
         virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
         virtual bool isComplete() const;
         virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         ~TraitInstType();
         virtual bool isComplete() const;
         virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         void set_isFtype( bool newValue ) { isFtype = newValue; }
         virtual bool isComplete() const;
         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override;
+        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+        virtual unsigned size() const override { return types.size(); };
         // For now, this is entirely synthetic -- tuple types always have unnamed members.
 …
         iterator end() { return types.end(); }
         virtual Type * getComponent( unsigned i ) {
+        virtual Type * getComponent( unsigned i ) override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
                 return *(begin()+i);
+        }
         // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
         virtual TupleType *clone() const { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
+        virtual TupleType *clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual bool isComplete() const { assert( false ); return false; }
         virtual TypeofType *clone() const { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); return false; }
+        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         void set_isType( bool newValue ) { isType = newValue; }
         virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
         virtual AttrType *clone() const { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
+        virtual AttrType *clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual bool isComplete() const{ return true; } // xxx - is this right?
         virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override{ return true; } // xxx - is this right?
+        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual ZeroType *clone() const { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
 };
 …
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        virtual OneType *clone() const { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Type * type );
+        virtual OneType *clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const override;
+};
 // Local Variables: //

src/SynTree/Visitor.h

r201aeb9	rd67cdb7
25	25	public:
26	26	// visit: Default implementation of all functions visits the children
27		// of the given syntax node, but performs no other action.
	27	// of the given syntax node, but performs no other action.
28	28
29	29	virtual void visit( ObjectDecl *objectDecl );

src/SynTree/module.mk

r201aeb9	rd67cdb7
48	48	SynTree/Visitor.cc \
49	49	SynTree/Mutator.cc \
50		~~SynTree/AddStmtVisitor.cc \~~
51	50	SynTree/TypeSubstitution.cc \
52	51	SynTree/Attribute.cc \

src/Tuples/TupleExpansion.cc

r201aeb9	rd67cdb7
21	21	#include "Common/ScopedMap.h" // for ScopedMap
22	22	#include "Common/utility.h" // for CodeLocation
23		~~#include "GenPoly/DeclMutator.h" // for DeclMutator~~
24	23	#include "InitTweak/InitTweak.h" // for getFunction
25	24	#include "Parser/LinkageSpec.h" // for Spec, C, Intrinsic

src/benchmark/Makefile.am

-              r201aeb9
+              rd67cdb7
         @rm -f a.out .result.log
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -lrt -pthread -DN=50000000 PthrdCtxSwitch.c
+        @rm -f .result.log
+        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
+                ./a.out | tee -a .result.log ; \
+        done
+        @./stat.py .result.log
+        @rm -f a.out .result.log
 sched-int$(EXEEXT):
         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c

src/benchmark/Makefile.in

-              r201aeb9
+              rd67cdb7
         @rm -f a.out .result.log
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ${AM_CFLAGS} ${CFLAGS} ${ccflags} -lrt -pthread -DN=50000000 PthrdCtxSwitch.c
+        @rm -f .result.log
+        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
+                ./a.out | tee -a .result.log ; \
+        done
+        @./stat.py .result.log
+        @rm -f a.out .result.log
 sched-int$(EXEEXT):
         ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c

src/benchmark/bench.h

-              r201aeb9
+              rd67cdb7
 #pragma once
+#ifdef __CFORALL__
 extern "C" {
+#endif
         #include <unistd.h>                                     // sysconf
         #include <sys/times.h>                                  // times
         #include <time.h>
+#ifdef __CFORALL__
+}
+#endif
 inline unsigned long long int Time() {
     timespec ts;
+static inline unsigned long long int Time() {
+    struct timespec ts;
     clock_gettime(
 #if defined( __linux__ )

src/benchmark/create_cfaThrd.c

r201aeb9	rd67cdb7
4	4
5	5	thread MyThread {};
6		void main(MyThread * this) {}
	6	void main(MyThread & this) {}
7	7
8	8	int main(int argc, char* argv[]) {

src/libcfa/Makefile.am

r201aeb9	rd67cdb7
36	36	${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
37	37
38		EXTRA_FLAGS = -g -Wall -W~~error -W~~no-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
	38	EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
39	39
40	40	AM_CCASFLAGS = @CFA_FLAGS@

src/libcfa/Makefile.in

r201aeb9	rd67cdb7
416	416	ARFLAGS = cr
417	417	lib_LIBRARIES = $(am__append_1) $(am__append_2)
418		EXTRA_FLAGS = -g -Wall -W~~error -W~~no-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
	418	EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
419	419	AM_CCASFLAGS = @CFA_FLAGS@
420	420	headers = fstream iostream iterator limits rational stdlib \

src/libcfa/concurrency/coroutine.c

r201aeb9	rd67cdb7
123	123	if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
124	124
125		~~LIB_DEBUG_PRINT_SAFE("FRED");~~
126
127	125	size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
128	126

src/libcfa/concurrency/invoke.h

-              r201aeb9
+              rd67cdb7
       };
+      struct __waitfor_mask_t {
+            short * accepted;                         // the index of the accepted function, -1 if none
+            struct __acceptable_t * clauses;          // list of acceptable functions, null if any
+            short size;                               // number of acceptable functions
+      };
       struct monitor_desc {
             struct spinlock lock;                     // spinlock to protect internal data
 …
             struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
             unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
+            struct __waitfor_mask_t mask;               // mask used to know if some thread is waiting for something while holding the monitor
+      };
+            struct __acceptable_t * acceptables;      // list of acceptable functions, null if any
+            unsigned short acceptable_count;          // number of acceptable functions
+            short accepted_index;                     // the index of the accepted function, -1 if none
+       };
+      struct __monitor_group_t {
+            struct monitor_desc ** list;              // currently held monitors
+            short                  size;              // number of currently held monitors
+            fptr_t                 func;              // last function that acquired monitors
+      };
       struct thread_desc {
             // Core threading fields
+            struct coroutine_desc cor;                // coroutine body used to store context
+            struct monitor_desc mon;                  // monitor body used for mutual exclusion
+            struct coroutine_desc  self_cor;          // coroutine body used to store context
+            struct monitor_desc    self_mon;          // monitor body used for mutual exclusion
+            struct monitor_desc *  self_mon_p;        // pointer to monitor with sufficient lifetime for current monitors
+            struct __monitor_group_t monitors;          // monitors currently held by this thread
             // Link lists fields
             struct thread_desc * next;                // instrusive link field for threads
+            // Current status related to monitors
+            struct monitor_desc ** current_monitors;  // currently held monitors
+            unsigned short current_monitor_count;     // number of currently held monitors
+            fptr_t current_monitor_func;              // last function that acquired monitors
      };
+     #ifdef __CFORALL__
+     extern "Cforall" {
+            static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
+                  return this.list[index];
+            }
+            static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                  if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                  if( lhs.size != rhs.size ) return false;
+                  if( lhs.func != rhs.func ) return false;
+                  // Check that all the monitors match
+                  for( int i = 0; i < lhs.size; i++ ) {
+                        // If not a match, check next function
+                        if( lhs[i] != rhs[i] ) return false;
+                  }
+                  return true;
+            }
+      }
+      #endif
 #endif //_INVOKE_H_

src/libcfa/concurrency/kernel.c

-              r201aeb9
+              rd67cdb7
 void ?{}( thread_desc & this, current_stack_info_t * info) {
         (this.cor){ info };
+        (this.self_cor){ info };
+}
 …
         // if( !thrd ) return;
         verify( thrd );
         verify( thrd->cor.state != Halted );
+        verify( thrd->self_cor.state != Halted );
         verify( disable_preempt_count > 0 );
 …
         assert(thrd);
         disable_interrupts();
         assert( thrd->cor.state != Halted );
+        assert( thrd->self_cor.state != Halted );
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
 …
         this_processor = mainProcessor;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
+        this_coroutine = &mainThread->self_cor;
         // Enable preemption
 …
         thread_desc * thrd = kernel_data;
         int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
+        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
         __lib_debug_write( STDERR_FILENO, abort_text, len );

src/libcfa/concurrency/monitor

-              r201aeb9
+              rd67cdb7
 #include "stdlib"
+trait is_monitor(dtype T) {
+        monitor_desc * get_monitor( T & );
+        void ^?{}( T & mutex );
+};
 static inline void ?{}(monitor_desc & this) {
         (this.lock){};
 …
         (this.signal_stack){};
         this.recursion = 0;
         this.acceptables = NULL;
         this.acceptable_count = 0;
         this.accepted_index = -1;
+        this.mask.accepted = NULL;
+        this.mask.clauses  = NULL;
+        this.mask.size     = 0;
+}
 …
 struct __acceptable_t {
+        fptr_t func;
+        unsigned short count;
+        monitor_desc ** monitors;
+        __monitor_group_t;
         bool is_dtor;
 };
 int __accept_internal( unsigned short count, __acceptable_t * acceptables );
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
 // Local Variables: //

src/libcfa/concurrency/monitor.c

-              r201aeb9
+              rd67cdb7
 //-----------------------------------------------------------------------------
 // Forward declarations
+static inline void set_owner( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc ** storage, short count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor_desc * this );
 static inline thread_desc * next_thread( monitor_desc * this );
 static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() );
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 static inline void lock_all( spinlock ** locks, unsigned short count );
 …
 static inline void unlock_all( monitor_desc ** locks, unsigned short count );
 static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count );
 static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count );
+static inline void save   ( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks );
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*in */ recursions, __waitfor_mask_t * /*in */ masks );
 static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
+static inline thread_desc * check_condition( __condition_criterion_t * );
+static inline void brand_condition( condition * );
+static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val );
+static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count );
+static inline thread_desc *        check_condition   ( __condition_criterion_t * );
+static inline void                 brand_condition   ( condition * );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
+forall(dtype T | sized( T ))
+static inline short insert_unique( T ** array, short & size, T * val );
+static inline short count_max    ( const __waitfor_mask_t & mask );
+static inline short aggregate    ( monitor_desc ** storage, const __waitfor_mask_t & mask );
 //-----------------------------------------------------------------------------
 // Useful defines
+#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack       */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
+        init( count, monitors, &waiter, criteria );               /* Link everything together                                          */ \
+#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack       */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
+        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack              */ \
+#define monitor_ctx( mons, cnt )              /* Define that create the necessary struct for internal/external scheduling operations */ \
+        monitor_desc ** monitors = mons;        /* Save the targeted monitors                                                          */ \
+        unsigned short count = cnt;             /* Save the count to a local variable                                                  */ \
+        unsigned int recursions[ count ];       /* Save the current recursion levels to restore them later                             */ \
+        spinlock *   locks     [ count ];       /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init( count, monitors, &waiter, criteria );               /* Link everything together                                                            */ \
+#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack                                */ \
+#define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
+        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
+        unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
+        __waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
+        spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define monitor_save    save   ( monitors, count, locks, recursions, masks )
+#define monitor_restore restore( monitors, count, locks, recursions, masks )
 //-----------------------------------------------------------------------------
 …
 extern "C" {
         // Enter single monitor
         static void __enter_monitor_desc( monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
+        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
 …
                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-                this->accepted_index = -1;
                 if( !this->owner ) {
                         // No one has the monitor, just take it
 …
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
+                }
                 else if( (this->accepted_index = is_accepted( thrd, this, group, group_cnt, func)) >= 0 ) {
+                else if( is_accepted( this, group) ) {
                         // Some one was waiting for us, enter
                         set_owner( this, thrd );
+                        // Reset mask
+                        reset_mask( this );
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
 …
                 lock_yield( &this->lock DEBUG_CTX2 );
+                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread, this->owner, this->recursion );
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
                 // Leaving a recursion level, decrement the counter
 …
         // Should never return
         void __leave_thread_monitor( thread_desc * thrd ) {
                 monitor_desc * this = &thrd->mon;
+                monitor_desc * this = &thrd->self_mon;
                 // Lock the monitor now
 …
                 disable_interrupts();
                 thrd->cor.state = Halted;
                 verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
+                thrd->self_cor.state = Halted;
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
                 // Leaving a recursion level, decrement the counter
 …
 // Enter multiple monitor
 // relies on the monitor array being sorted
 static inline void enter(monitor_desc ** monitors, int count, void (*func)() ) {
         for(int i = 0; i < count; i++) {
                 __enter_monitor_desc( monitors[i], monitors, count, func );
+static inline void enter( __monitor_group_t monitors ) {
+        for(int i = 0; i < monitors.size; i++) {
+                __enter_monitor_desc( monitors.list[i], monitors );
+        }
+}
 …
         // Save previous thread context
         this.prev_mntrs = this_thread->current_monitors;
         this.prev_count = this_thread->current_monitor_count;
         this.prev_func  = this_thread->current_monitor_func;
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
         // Update thread context (needed for conditions)
+        this_thread->current_monitors      = m;
+        this_thread->current_monitor_count = count;
+        this_thread->current_monitor_func  = func;
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = count;
+        this_thread->monitors.func = func;
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
         // Enter the monitors in order
+        enter( this.m, this.count, func );
+        __monitor_group_t group = {this.m, this.count, func};
+        enter( group );
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+}
 …
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
         // Leave the monitors in order
         leave( this.m, this.count );
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
         // Restore thread context
         this_thread->current_monitors      = this.prev_mntrs;
         this_thread->current_monitor_count = this.prev_count;
         this_thread->current_monitor_func  = this.prev_func;
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+}
 …
         append( &this->blocked, &waiter );
         // Lock all monitors (aggregates the lock them as well)
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
-        // DON'T unlock, ask the kernel to do it
-        // Save monitor state
-        save_recursion( monitors, recursions, count );
         // Find the next thread(s) to run
         unsigned short thread_count = 0;
+        short thread_count = 0;
         thread_desc * threads[ count ];
         for(int i = 0; i < count; i++) {
 …
+        }
+        // Save monitor states
+        monitor_save;
         // Remove any duplicate threads
         for( int i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( monitors[i] );
                 thread_count = insert_unique( threads, thread_count, new_owner );
+                insert_unique( threads, thread_count, new_owner );
+        }
 …
         BlockInternal( locks, count, threads, thread_count );
-        // WE WOKE UP
         // We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( monitors, recursions, count );
+        unlock_all( locks, count );
+        monitor_restore;
+}
 …
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
                 if ( this->monitor_count != this_thrd->current_monitor_count ) {
                         abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->current_monitor_count );
+                if ( this->monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
+                }
                 for(int i = 0; i < this->monitor_count; i++) {
                         if ( this->monitors[i] != this_thrd->current_monitors[i] ) {
                                 abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->current_monitors[i] );
+                        if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
+                        }
+                }
 …
         //save contexts
         save_recursion( monitors, recursions, count );
+        monitor_save;
         //Find the thread to run
         thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
+        for(int i = 0; i < count; i++) {
+                set_owner( monitors[i], signallee );
+        }
+        set_owner( monitors, count, signallee );
         //Everything is ready to go to sleep
 …
+        //We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( monitors, recursions, count );
+        unlock_all( locks, count );
+        //We are back, restore the masks and recursions
+        monitor_restore;
         return true;
 …
 //-----------------------------------------------------------------------------
+// Internal scheduling
+int __accept_internal( unsigned short acc_count, __acceptable_t * acceptables ) {
+        thread_desc * thrd = this_thread;
+// External scheduling
+// cases to handle :
+//      - target already there :
+//              block and wake
+//      - dtor already there
+//              put thread on signaller stack
+//      - non-blocking
+//              return else
+//      - timeout
+//              return timeout
+//      - block
+//              setup mask
+//              block
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) {
+        // This statment doesn't have a contiguous list of monitors...
+        // Create one!
+        short max = count_max( mask );
+        monitor_desc * mon_storage[max];
+        short actual_count = aggregate( mon_storage, mask );
+        if(actual_count == 0) return;
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
         // Create storage for monitor context
         monitor_ctx( acceptables->monitors, acceptables->count );
         // Lock all monitors (aggregates the lock them as well)
+        monitor_ctx( mon_storage, actual_count );
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
+        {
+                // Check if the entry queue
+                thread_desc * next; int index;
+                [next, index] = search_entry_queue( mask, monitors, count );
+                if( next ) {
+                        *mask.accepted = index;
+                        if( mask.clauses[index].is_dtor ) {
+                                #warning case not implemented
+                        }
+                        else {
+                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, baton-passing\n");
+                                // Create the node specific to this wait operation
+                                wait_ctx_primed( this_thread, 0 );
+                                // Save monitor states
+                                monitor_save;
+                                // Set the owners to be the next thread
+                                set_owner( monitors, count, next );
+                                // Everything is ready to go to sleep
+                                BlockInternal( locks, count, &next, 1 );
+                                // We are back, restore the owners and recursions
+                                monitor_restore;
+                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, returned\n");
+                        }
+                        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+                        return;
+                }
+        }
+        if( duration == 0 ) {
+                LIB_DEBUG_PRINT_SAFE("Kernel : non-blocking, exiting\n");
+                unlock_all( locks, count );
+                LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+                return;
+        }
+        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
+        LIB_DEBUG_PRINT_SAFE("Kernel : blocking waitfor\n");
         // Create the node specific to this wait operation
+        wait_ctx_primed( thrd, 0 );
+        // Check if the entry queue
+        thread_desc * next = search_entry_queue( acceptables, acc_count, monitors, count );
+        LIB_DEBUG_PRINT_SAFE("Owner(s) :");
+        wait_ctx_primed( this_thread, 0 );
+        monitor_save;
+        set_mask( monitors, count, mask );
         for(int i = 0; i < count; i++) {
+                LIB_DEBUG_PRINT_SAFE(" %p", monitors[i]->owner );
+        }
+        LIB_DEBUG_PRINT_SAFE("\n");
+        LIB_DEBUG_PRINT_SAFE("Passing mon to %p\n", next);
+        if( !next ) {
+                // Update acceptables on the current monitors
+                for(int i = 0; i < count; i++) {
+                        monitors[i]->acceptables = acceptables;
+                        monitors[i]->acceptable_count = acc_count;
+                }
+        }
+        else {
+                for(int i = 0; i < count; i++) {
+                        set_owner( monitors[i], next );
+                }
+        }
+        save_recursion( monitors, recursions, count );
+        // Everything is ready to go to sleep
+        BlockInternal( locks, count, &next, next ? 1 : 0 );
+        //WE WOKE UP
+        //We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( monitors, recursions, count );
+        int acc_idx = monitors[0]->accepted_index;
+        unlock_all( locks, count );
+        return acc_idx;
+                verify( monitors[i]->owner == this_thread );
+        }
+        //Everything is ready to go to sleep
+        BlockInternal( locks, count );
+        // WE WOKE UP
+        //We are back, restore the masks and recursions
+        monitor_restore;
+        LIB_DEBUG_PRINT_SAFE("Kernel : exiting\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+}
 …
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
+        // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
         //Pass the monitor appropriately
         this->owner = owner;
 …
         //We are passing the monitor to someone else, which means recursion level is not 0
         this->recursion = owner ? 1 : 0;
+}
+static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
+        for( int i = 0; i < count; i++ ) {
+                set_owner( monitors[i], owner );
+        }
+}
+static inline void set_mask( monitor_desc ** storage, short count, const __waitfor_mask_t & mask ) {
+        for(int i = 0; i < count; i++) {
+                storage[i]->mask = mask;
+        }
+}
+static inline void reset_mask( monitor_desc * this ) {
+        this->mask.accepted = NULL;
+        this->mask.clauses = NULL;
+        this->mask.size = 0;
+}
 …
+}
 static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
         __acceptable_t* accs = this->acceptables; // Optim
         int acc_cnt = this->acceptable_count;
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+        __acceptable_t * it = this->mask.clauses; // Optim
+        int count = this->mask.size;
         // Check if there are any acceptable functions
         if( !accs ) return -1;
+        if( !it ) return false;
         // If this isn't the first monitor to test this, there is no reason to repeat the test.
         if( this != group[0] ) return group[0]->accepted_index;
+        if( this != group[0] ) return group[0]->mask.accepted >= 0;
         // For all acceptable functions check if this is the current function.
+        OUT_LOOP:
+        for( int i = 0; i < acc_cnt; i++ ) {
+                __acceptable_t * acc = &accs[i];
+                // if function matches, check the monitors
+                if( acc->func == func ) {
+                        // If the group count is different then it can't be a match
+                        if( acc->count != group_cnt ) return -1;
+                        // Check that all the monitors match
+                        for( int j = 0; j < group_cnt; j++ ) {
+                                // If not a match, check next function
+                                if( acc->monitors[j] != group[j] ) continue OUT_LOOP;
+                        }
+                        // It's a complete match, accept the call
+                        return i;
+        for( short i = 0; i < count; i++, it++ ) {
+                if( *it == group ) {
+                        *this->mask.accepted = i;
+                        return true;
+                }
+        }
         // No function matched
         return -1;
+        return false;
+}
 …
+}
+static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count ) {
+static inline void save( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
         for( int i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;
+        }
+}
+static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count ) {
+                masks[i]      = ctx[i]->mask;
+        }
+}
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+        lock_all( locks, count );
         for( int i = 0; i < count; i++ ) {
                 ctx[i]->recursion = recursions[i];
+        }
+                ctx[i]->mask      = masks[i];
+        }
+        unlock_all( locks, count );
+}
 …
         if( !this->monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->current_monitors != NULL, "No current monitor to brand condition %p", thrd->current_monitors );
                 this->monitor_count = thrd->current_monitor_count;
+                assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
+                this->monitor_count = thrd->monitors.size;
                 this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
                 for( int i = 0; i < this->monitor_count; i++ ) {
+                        this->monitors[i] = thrd->current_monitors[i];
+                }
+        }
+}
+static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val ) {
+        if( !val ) return end;
+        for(int i = 0; i <= end; i++) {
+                if( thrds[i] == val ) return end;
+        }
+        thrds[end] = val;
+        return end + 1;
+}
+static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
+        verify( thrd );
+        verify( acc );
+        if( acc->func != thrd->current_monitor_func ) return false;
+        return true;
+}
+static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count ) {
+                        this->monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc ** monitors, int count ) {
         __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
 …
         for(    thread_desc ** thrd_it = &entry_queue->head;
                 *thrd_it;
                 thrd_it = &(*thrd_it)->next)
+        {
+                thrd_it = &(*thrd_it)->next
+        ) {
                 // For each acceptable check if it matches
+                __acceptable_t * acc_end = acceptables + acc_count;
+                for( __acceptable_t * acc_it = acceptables; acc_it != acc_end; acc_it++ ) {
+                int i = 0;
+                __acceptable_t * end = mask.clauses + mask.size;
+                for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
                         // Check if we have a match
                         if( match( acc_it, *thrd_it ) ) {
+                        if( *it == (*thrd_it)->monitors ) {
                                 // If we have a match return it
                                 // after removeing it from the entry queue
                                 return remove( entry_queue, thrd_it );
+                                return [remove( entry_queue, thrd_it ), i];
+                        }
+                }
+        }
+        return NULL;
+}
+        return [0, -1];
+}
+forall(dtype T | sized( T ))
+static inline short insert_unique( T ** array, short & size, T * val ) {
+        if( !val ) return size;
+        for(int i = 0; i <= size; i++) {
+                if( array[i] == val ) return size;
+        }
+        array[size] = val;
+        size = size + 1;
+        return size;
+}
+static inline short count_max( const __waitfor_mask_t & mask ) {
+        short max = 0;
+        for( int i = 0; i < mask.size; i++ ) {
+                max += mask.clauses[i].size;
+        }
+        return max;
+}
+static inline short aggregate( monitor_desc ** storage, const __waitfor_mask_t & mask ) {
+        short size = 0;
+        for( int i = 0; i < mask.size; i++ ) {
+                for( int j = 0; j < mask.clauses[i].size; j++) {
+                        insert_unique( storage, size, mask.clauses[i].list[j] );
+                }
+        }
+        qsort( storage, size );
+        return size;
+}
 void ?{}( __condition_blocked_queue_t & this ) {
         this.head = NULL;

src/libcfa/concurrency/preemption.c

-              r201aeb9
+              rd67cdb7
                 siginfo_t info;
                 int sig = sigwaitinfo( &mask, &info );
+                if( sig < 0 ) {
+                        //Error!
+                        int err = errno;
+                        switch( err ) {
+                                case EAGAIN :
+                                case EINTR :
+                                        continue;
+                        case EINVAL :
+                                        abortf("Timeout was invalid.");
+                                default:
+                                        abortf("Unhandled error %d", err);
+                        }
+                }
                 // If another signal arrived something went wrong

src/libcfa/concurrency/thread

r201aeb9	rd67cdb7
36	36	forall( dtype T \| is_thread(T) )
37	37	static inline coroutine_desc* get_coroutine(T & this) {
38		return &get_thread(this)->cor;
	38	return &get_thread(this)->self_cor;
39	39	}
40	40
41	41	forall( dtype T \| is_thread(T) )
42	42	static inline monitor_desc* get_monitor(T & this) {
43		return &get_thread(this)->mon;
	43	return &get_thread(this)->self_mon;
44	44	}
45	45
46	46	static inline coroutine_desc* get_coroutine(thread_desc * this) {
47		return &this->cor;
	47	return &this->self_cor;
48	48	}
49	49
50	50	static inline monitor_desc* get_monitor(thread_desc * this) {
51		return &this->mon;
	51	return &this->self_mon;
52	52	}
53	53

src/libcfa/concurrency/thread.c

-              r201aeb9
+              rd67cdb7
 void ?{}(thread_desc& this) {
+        (this.cor){};
+        this.cor.name = "Anonymous Coroutine";
+        this.mon.owner = &this;
+        this.mon.recursion = 1;
+        (this.self_cor){};
+        this.self_cor.name = "Anonymous Coroutine";
+        this.self_mon.owner = &this;
+        this.self_mon.recursion = 1;
+        this.self_mon_p = &this.self_mon;
         this.next = NULL;
+        this.current_monitors      = &this.mon;
+        this.current_monitor_count = 1;
+        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+}
 void ^?{}(thread_desc& this) {
         ^(this.cor){};
+        ^(this.self_cor){};
+}

src/main.cc

-              r201aeb9
+              rd67cdb7
                 } // if
-                // OPTPRINT( "Concurrency" )
-                // Concurrency::applyKeywords( translationUnit );
                 // add the assignment statement after the initialization of a type parameter
                 OPTPRINT( "validate" )

src/prelude/prelude.cf

-              r201aeb9
+              rd67cdb7
 _Bool                   ?--( _Bool & ),                         ?--( volatile _Bool & );
 unsigned char           ?++( unsigned char & ),                 ?++( volatile unsigned char & );
+signed short            ?++( signed short & ),                  ?++( volatile signed short & );
+signed short            ?--( signed short & ),                  ?--( volatile signed short & );
+unsigned short          ?++( unsigned short & ),                ?++( volatile unsigned short & );
+unsigned short          ?--( unsigned short & ),                ?--( volatile unsigned short & );
 signed int              ?++( signed int & ),                    ?++( volatile signed int & );
 signed int              ?--( signed int & ),                    ?--( volatile signed int & );
 …
 _Bool                   ++?( _Bool & ),                         --?( _Bool & );
+signed short    ++?( signed short & ),                  --?( signed short & );
 signed int              ++?( signed int & ),                    --?( signed int & );
+unsigned int            ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned short          ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned int            ++?( unsigned short & ),                --?( unsigned short & );
 signed long int         ++?( signed long int & ),               --?( signed long int & );
 unsigned long int       ++?( unsigned long int & ),             --?( unsigned long int & );

src/tests/Makefile.am

-              r201aeb9
+              rd67cdb7
 concurrent = yes
 quick_test += coroutine thread monitor
 concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
+concurrent_test = coroutine thread monitor multi-monitor sched-int-block sched-int-disjoint sched-int-wait sched-ext-barge sched-ext-else sched-ext-parse sched-ext-statment preempt
 else
 concurrent=no
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/Makefile.in

-              r201aeb9
+              rd67cdb7
 @BUILD_CONCURRENCY_TRUE@concurrent = yes
 @BUILD_CONCURRENCY_FALSE@concurrent_test =
 @BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
+@BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-block sched-int-disjoint sched-int-wait sched-ext-barge sched-ext-else sched-ext-parse sched-ext-statment preempt
 # applies to both programs
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}

src/tests/sched-ext-parse.c

r201aeb9	rd67cdb7
80	80	16;
81	81	}
82		or waitfor( f1, a, a ) {
	82	or waitfor( f2, a, a ) {
83	83	17;
84	84	}

src/tests/sched-ext.c

r201aeb9	rd67cdb7
45	45	acceptable.monitors = &a;
46	46
47		__~~accept~~_internal( 1, &acceptable );
	47	__waitfor_internal( 1, &acceptable );
48	48
49	49	sout \| "Accepted" \| endl;

Context Navigation

Legend:

Download in other formats: