Changeset 6840e7c

doc/LaTeXmacros/lstlang.sty

-              rb96ec83
+              r6840e7c
 %%
 %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 %%
 %% lstlang.sty --
 %%
+%%
+%% lstlang.sty --
+%%
 %% Author           : Peter A. Buhr
 %% Created On       : Sat May 13 16:34:42 2017
 …
                 __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
                 __const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru,
                 finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
                 otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
                 __typeof__, virtual, waitfor, when, with, zero_t},
+                finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
+                otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
+                __typeof__, virtual, with, zero_t},
         morekeywords=[2]{
                 _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex,
                 resume, suspend, thread, _Thread_local, yield},
+                _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex, or,
+                resume, suspend, thread, _Thread_local, waitfor, when, yield},
         moredirectives={defined,include_next}%
+}

doc/proposals/concurrency/Makefile

-              rb96ec83
+              r6840e7c
 text/basics \
 text/concurrency \
+text/internals \
 text/parallelism \
+text/together \
+text/future \
+}
 …
         ext_monitor \
         int_monitor \
+        dependency \
 }}

doc/proposals/concurrency/annex/glossary.tex

-              rb96ec83
+              r6840e7c
+}
 \longnewglossaryentry{group-acquire}
 {name={bulk acquiring}}
+\longnewglossaryentry{bulk-acq}
+{name={bulk-acquiring}}
+{
 Implicitly acquiring several monitors when entering a monitor.
+}
+\longnewglossaryentry{multi-acq}
+{name={multiple-acquisition}}
+{
+Any locking technique which allow any single thread to acquire a lock multiple times.
+}
 …
 \newacronym{api}{API}{Application Program Interface}
 \newacronym{raii}{RAII}{Ressource Acquisition Is Initialization}
+\newacronym{numa}{NUMA}{Non-Uniform Memory Access}

doc/proposals/concurrency/figures/ext_monitor.fig

-              rb96ec83
+              r6840e7c
 1 -1 0 0 0 10 0.0000 2 105 90 6000 2160 d\001
 -6
 5850 1650 6150 1950
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905
 1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001
+5100 2100 5400 2400
+3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250
+1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001
 -6
 5100 1800 5400 2100
 …
 1 -1 0 0 0 10 0.0000 2 105 120 5250 2010 Y\001
 -6
 5100 2100 5400 2400
 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250
 1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001
+5850 1650 6150 1950
+3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905
+1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001
 -6
 3000 5400 7200 5700
+3070 5445 7275 5655
 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 3150 5550 80 80 3150 5550 3230 5630
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4500 5550 105 105 4500 5550 4605 5655
 …
 0 -1 0 0 0 12 0.0000 2 135 1035 4725 5625 blocked task\001
 0 -1 0 0 0 12 0.0000 2 135 870 3300 5625 active task\001
 0 -1 0 0 0 12 0.0000 2 180 930 6225 5625 routine ptrs\001
+0 -1 0 0 0 12 0.0000 2 135 1050 6225 5625 routine mask\001
 -6
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3300 3600 105 105 3300 3600 3405 3705
 …
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 2925 5475 2925 5475 3225 4050 3225 4050 2925
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2
-2850 6075 3000
 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4
 3750 3750 3750 3750 4050 3150 4050
 …
 2 1 1 -1 -1 0 0 -1 4.000 0 0 0 0 0 5
 4200 5850 3300 4350 3300 4350 4200 5850 4200
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3
-2850 5850 2850 5850 1650
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4
-3150 3750 3150 3750 2850 5325 2850
 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2
 1 1.00 60.00 120.00
 1 1.00 60.00 120.00
 3150 5250 2400
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
+3150 3750 3150 3750 2850 5850 2850 5850 1650
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
+2850 6150 3000
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 1800 5400 1800 5400 2400 5100 2400 5100 1800

doc/proposals/concurrency/style/cfa-format.tex

-              rb96ec83
+              r6840e7c
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,
 …
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,
 …
   keywordstyle=\bfseries\color{blue},
   keywordstyle=[2]\bfseries\color{Plum},
   commentstyle=\itshape\color{OliveGreen},                  % green and italic comments
+  commentstyle=\sf\itshape\color{OliveGreen},             % green and italic comments
   identifierstyle=\color{identifierCol},
   stringstyle=\sf\color{Mahogany},                                % use sanserif font
 …
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,

doc/proposals/concurrency/text/basics.tex

-              rb96ec83
+              r6840e7c
 % ======================================================================
 % ======================================================================
 \chapter{Basics}\label{basics}
+\chapter{Concurrency Basics}\label{basics}
 % ======================================================================
 % ======================================================================
 Before any detailed discussion of the concurrency and parallelism in \CFA, it is important to describe the basics of concurrency and how they are expressed in \CFA user code.
+Before any detailed discussion of the concurrency and parallelism in \CFA, it is important to describe the basics of concurrency and how they are expressed in \CFA user-code.
 \section{Basics of concurrency}
+At its core, concurrency is based on having call-stacks and potentially multiple threads of execution for these stacks. Concurrency without parallelism only requires having multiple call stacks (or contexts) for a single thread of execution, and switching between these call stacks on a regular basis. A minimal concurrency product can be achieved by creating coroutines, which instead of context switching between each other, always ask an oracle where to context switch next. While coroutines do not technically require a stack, stackfull coroutines are the closest abstraction to a practical "naked"" call stack. When writing concurrency in terms of coroutines, the oracle effectively becomes a scheduler and the whole system now follows a cooperative threading-model \cit. The oracle/scheduler can either be a stackless or stackfull entity and correspondingly require one or two context switches to run a different coroutine. In any case, a subset of concurrency related challenges start to appear. For the complete set of concurrency challenges to occur, the only feature missing is preemption. Indeed, concurrency challenges appear with non-determinism. Guaranteeing mutual-exclusion or synchronisation are simply ways of limiting the lack of determinism in a system. A scheduler introduces order of execution uncertainty, while preemption introduces incertainty about where context-switches occur. Now it is important to understand that uncertainty is not necessarily undesireable; uncertainty can often be used by systems to significantly increase performance and is often the basis of giving a user the illusion that tasks are running in parallel. Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows\cit.
+At its core, concurrency is based on having multiple call-stacks and scheduling among threads of execution executing on these stacks. Concurrency without parallelism only requires having multiple call stacks (or contexts) for a single thread of execution.
+Indeed, while execution with a single thread and multiple stacks where the thread is self-scheduling deterministically across the stacks is called coroutining, execution with a single and multiple stacks but where the thread is scheduled by an oracle (non-deterministic from the thread perspective) across the stacks is called concurrency.
+Therefore, a minimal concurrency system can be achieved by creating coroutines, which instead of context switching among each other, always ask an oracle where to context switch next. While coroutines can execute on the caller's stack-frame, stackfull coroutines allow full generality and are sufficient as the basis for concurrency. The aforementioned oracle is a scheduler and the whole system now follows a cooperative threading-model \cit. The oracle/scheduler can either be a stackless or stackfull entity and correspondingly require one or two context switches to run a different coroutine. In any case, a subset of concurrency related challenges start to appear. For the complete set of concurrency challenges to occur, the only feature missing is preemption. Indeed, concurrency challenges appear with non-determinism. Using mutual-exclusion or synchronisation are ways of limiting the lack of determinism in a system. A scheduler introduces order of execution uncertainty, while preemption introduces uncertainty about where context-switches occur. Now it is important to understand that uncertainty is not undesireable; uncertainty can often be used by systems to significantly increase performance and is often the basis of giving a user the illusion that tasks are running in parallel. Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows\cit.
 \section{\protect\CFA 's Thread Building Blocks}
 One of the important features that is missing in C is threading. On modern architectures, a lack of threading is becoming less and less forgivable\cite{Sutter05, Sutter05b}, and therefore modern programming languages must have the proper tools to allow users to write performant concurrent and/or parallel programs. As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers used to imperative languages. And being a system-level language means programmers expect to choose precisely which features they need and which cost they are willing to pay.
+One of the important features that is missing in C is threading. On modern architectures, a lack of threading is unacceptable\cite{Sutter05, Sutter05b}, and therefore modern programming languages must have the proper tools to allow users to write performant concurrent and/or parallel programs. As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers familiar with imperative languages. And being a system-level language means programmers expect to choose precisely which features they need and which cost they are willing to pay.
 \section{Coroutines: A stepping stone}\label{coroutine}
+While the main focus of this proposal is concurrency and parallelism, as mentionned above it is important to adress coroutines, which are actually a significant underlying aspect of a concurrency system. Indeed, while having nothing to do with parallelism and arguably little to do with concurrency, coroutines need to deal with context-switchs and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core API of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
+Here is an example of a solution to the fibonnaci problem using \CFA coroutines:
+\begin{cfacode}
+        coroutine Fibonacci {
+              int fn; // used for communication
+        };
+        void ?{}(Fibonacci & this) { // constructor
+              this.fn = 0;
+        }
+        // main automacically called on first resume
+        void main(Fibonacci & this) {
+                int fn1, fn2;           // retained between resumes
+                this.fn = 0;
+                fn1 = this.fn;
+                suspend(this);          // return to last resume
+                this.fn = 1;
+While the main focus of this proposal is concurrency and parallelism, it is important to address coroutines, which are actually a significant building block of a concurrency system. Coroutines need to deal with context-switchs and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core \acrshort{api} of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
+A good example of a problem made easier with coroutines is genereting the fibonacci sequence. This problem comes with the challenge of decoupling how a sequence is generated and how it is used. Figure \ref{fig:fibonacci-c} shows conventional approaches to writing generators in C. All three of these approach suffer from strong coupling. The left and center approaches require that the generator have knowledge of how the sequence will be used, while the rightmost approach requires to user to hold internal state between calls on behalf of th sequence generator and makes it much harder to handle corner cases like the Fibonacci seed.
+\begin{figure}
+\label{fig:fibonacci-c}
+\begin{center}
+\begin{tabular}{c @{\hskip 0.025in}|@{\hskip 0.025in} c @{\hskip 0.025in}|@{\hskip 0.025in} c}
+\begin{ccode}[tabsize=2]
+//Using callbacks
+void fibonacci_func(
+        int n,
+        void (*callback)(int)
+) {
+        int first = 0;
+        int second = 1;
+        int next, i;
+        for(i = 0; i < n; i++)
+        {
+                if(i <= 1)
+                        next = i;
+                else {
+                        next = f1 + f2;
+                        f1 = f2;
+                        f2 = next;
+                }
+                callback(next);
+        }
+}
+\end{ccode}&\begin{ccode}[tabsize=2]
+//Using output array
+void fibonacci_array(
+        int n,
+        int * array
+) {
+        int f1 = 0; int f2 = 1;
+        int next, i;
+        for(i = 0; i < n; i++)
+        {
+                if(i <= 1)
+                        next = i;
+                else {
+                        next = f1 + f2;
+                        f1 = f2;
+                        f2 = next;
+                }
+                *array = next;
+                array++;
+        }
+}
+\end{ccode}&\begin{ccode}[tabsize=2]
+//Using external state
+typedef struct {
+        int f1, f2;
+} iterator_t;
+int fibonacci_state(
+        iterator_t * it
+) {
+        int f;
+        f = it->f1 + it->f2;
+        it->f2 = it->f1;
+        it->f1 = f;
+        return f;
+}
+\end{ccode}
+\end{tabular}
+\end{center}
+\caption{Different implementations of a fibonacci sequence generator in C.}
+\end{figure}
+Figure \ref{fig:fibonacci-cfa} is an example of a solution to the fibonnaci problem using \CFA coroutines, using the coroutine stack to hold sufficient state for the generation. This solution has the advantage of having very strong decoupling between how the sequence is generated and how it is used. Indeed, this version is a easy to use as the \code{fibonacci_state} solution, while the imlpementation is very similar to the \code{fibonacci_func} example.
+\begin{figure}
+\label{fig:fibonacci-cfa}
+\begin{cfacode}
+coroutine Fibonacci {
+        int fn; //used for communication
+};
+void ?{}(Fibonacci & this) { //constructor
+        this.fn = 0;
+}
+//main automacically called on first resume
+void main(Fibonacci & this) {
+        int fn1, fn2;           //retained between resumes
+        this.fn = 0;
+        fn1 = this.fn;
+        suspend(this);          //return to last resume
+        this.fn = 1;
+        fn2 = fn1;
+        fn1 = this.fn;
+        suspend(this);          //return to last resume
+        for ( ;; ) {
+                this.fn = fn1 + fn2;
                 fn2 = fn1;
                 fn1 = this.fn;
+                suspend(this);          // return to last resume
+                for ( ;; ) {
+                        this.fn = fn1 + fn2;
+                        fn2 = fn1;
+                        fn1 = this.fn;
+                        suspend(this);  // return to last resume
+                }
+        }
+        int next(Fibonacci & this) {
+                resume(this); // transfer to last suspend
+                return this.fn;
+        }
+        void main() { // regular program main
+                Fibonacci f1, f2;
+                for ( int i = 1; i <= 10; i += 1 ) {
+                        sout | next( f1 ) | next( f2 ) | endl;
+                }
+        }
+\end{cfacode}
+                suspend(this);  //return to last resume
+        }
+}
+int next(Fibonacci & this) {
+        resume(this); //transfer to last suspend
+        return this.fn;
+}
+void main() { //regular program main
+        Fibonacci f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( f1 ) | next( f2 ) | endl;
+        }
+}
+\end{cfacode}
+\caption{Implementation of fibonacci using coroutines}
+\end{figure}
 \subsection{Construction}
 One important design challenge for coroutines and threads (shown in section \ref{threads}) is that the runtime system needs to run code after the user-constructor runs. In the case of coroutines, this challenge is simpler since there is no non-determinism from preemption or scheduling. However, the underlying challenge remains the same for coroutines and threads.
 The runtime system needs to create the coroutine's stack and more importantly prepare it for the first resumption. The timing of the creation is non-trivial since users both expect to have fully constructed objects once execution enters the coroutine main and to be able to resume the coroutine from the constructor. Like for regular objects, constructors can still leak coroutines before they are ready. There are several solutions to this problem but the chosen options effectively forces the design of the coroutine.
+One important design challenge for coroutines and threads (shown in section \ref{threads}) is that the runtime system needs to run code after the user-constructor runs to connect the object into the system. In the case of coroutines, this challenge is simpler since there is no non-determinism from preemption or scheduling. However, the underlying challenge remains the same for coroutines and threads.
+The runtime system needs to create the coroutine's stack and more importantly prepare it for the first resumption. The timing of the creation is non-trivial since users both expect to have fully constructed objects once execution enters the coroutine main and to be able to resume the coroutine from the constructor. As regular objects, constructors can leak coroutines before they are ready. There are several solutions to this problem but the chosen options effectively forces the design of the coroutine.
 Furthermore, \CFA faces an extra challenge as polymorphic routines create invisible thunks when casted to non-polymorphic routines and these thunks have function scope. For example, the following code, while looking benign, can run into undefined behaviour because of thunks:
 …
+}
 \end{cfacode}
 The generated C code\footnote{Code trimmed down for brevity} creates a local thunk to hold type information:
 …
+}
 \end{ccode}
 The problem in this example is a race condition between the start of the execution of \code{noop} on the other thread and the stack frame of \code{bar} being destroyed. This extra challenge limits which solutions are viable because storing the function pointer for too long only increases the chances that the race will end in undefined behavior; i.e. the stack based thunk being destroyed before it was used. This challenge is an extension of challenges that come with second-class routines. Indeed, GCC nested routines also have the limitation that the routines cannot be passed outside of the scope of the functions these were declared in. The case of coroutines and threads is simply an extension of this problem to multiple call-stacks.
+The problem in this example is a storage management issue, the function pointer \code{_thunk0} is only valid until the end of the block. This extra challenge limits which solutions are viable because storing the function pointer for too long causes undefined behavior; i.e. the stack based thunk being destroyed before it was used. This challenge is an extension of challenges that come with second-class routines. Indeed, GCC nested routines also have the limitation that the routines cannot be passed outside of the scope of the functions these were declared in. The case of coroutines and threads is simply an extension of this problem to multiple call-stacks.
 \subsection{Alternative: Composition}
+One solution to this challenge would be to use composition/containement,
+\begin{cfacode}
+        struct Fibonacci {
+              int fn; // used for communication
+              coroutine c; //composition
+        };
+        void ?{}(Fibonacci & this) {
+              this.fn = 0;
+                (this.c){};
+        }
+\end{cfacode}
+There are two downsides to this approach. The first, which is relatively minor, is that the base class needs to be made aware of the main routine pointer, regardless of whether a parameter or a virtual pointer is used, this means the coroutine data must be made larger to store a value that is actually a compile time constant (address of the main routine). The second problem, which is both subtle and significant, is that now users can get the initialisation order of there coroutines wrong. Indeed, every field of a \CFA struct is constructed but in declaration order, unless users explicitly write otherwise. This semantics means that users who forget to initialize a the coroutine may resume the coroutine with an uninitilized object. For coroutines, this is unlikely to be a problem, for threads however, this is a significant problem.
+One solution to this challenge is to use composition/containement, where uses add insert a coroutine field which contains the necessary information to manage the coroutine.
+\begin{cfacode}
+struct Fibonacci {
+        int fn; //used for communication
+        coroutine c; //composition
+};
+void ?{}(Fibonacci & this) {
+        this.fn = 0;
+        (this.c){}; //Call constructor to initialize coroutine
+}
+\end{cfacode}
+There are two downsides to this approach. The first, which is relatively minor, made aware of the main routine pointer. This information must either be store in the coroutine runtime data or in its static type structure. When using composition, all coroutine handles have the same static type structure which means the pointer to the main needs to be part of the runtime data. This requirement means the coroutine data must be made larger to store a value that is actually a compile time constant (address of the main routine). The second problem, which is both subtle and significant, is that now users can get the initialisation order of coroutines wrong. Indeed, every field of a \CFA struct is constructed but in declaration order, unless users explicitly write otherwise. This semantics means that users who forget to initialize the coroutine handle may resume the coroutine with an uninitilized object. For coroutines, this is unlikely to be a problem, for threads however, this is a significant problem. Figure \ref{fig:fmt-line} shows the \code{Format} coroutine which rearranges text in order to group characters into blocks of fixed size. This is a good example where the control flow is made much simpler from being able to resume the coroutine from the constructor and highlights the idea that interesting control flow can occor in the constructor.
+\begin{figure}
+\label{fig:fmt-line}
+\begin{cfacode}[tabsize=3]
+//format characters into blocks of 4 and groups of 5 blocks per line
+coroutine Format {
+        char ch;                                                                        //used for communication
+        int g, b;                                                               //global because used in destructor
+};
+void  ?{}(Format & fmt) {
+        resume( fmt );                                                  //prime (start) coroutine
+}
+void ^?{}(Format & fmt) with fmt {
+        if ( fmt.g != 0 || fmt.b != 0 )
+        sout | endl;
+}
+void main(Format & fmt) with fmt {
+        for ( ;; ) {                                                    //for as many characters
+                for(g = 0; g < 5; g++) {                //groups of 5 blocks
+                        for(b = 0; b < 4; fb++) {       //blocks of 4 characters
+                                suspend();
+                                sout | ch;                                      //print character
+                        }
+                        sout | "  ";                                    //print block separator
+                }
+                sout | endl;                                            //print group separator
+        }
+}
+void prt(Format & fmt, char ch) {
+        fmt.ch = ch;
+        resume(fmt);
+}
+int main() {
+        Format fmt;
+        char ch;
+        Eof: for ( ;; ) {                                               //read until end of file
+                sin | ch;                                                       //read one character
+                if(eof(sin)) break Eof;                 //eof ?
+                prt(fmt, ch);                                           //push character for formatting
+        }
+}
+\end{cfacode}
+\caption{Formatting text into lines of 5 blocks of 4 characters.}
+\end{figure}
 \subsection{Alternative: Reserved keyword}
 …
 \begin{cfacode}
+        coroutine Fibonacci {
+              int fn; // used for communication
+        };
+\end{cfacode}
+This mean the compiler can solve problems by injecting code where needed. The downside of this approach is that it makes coroutine a special case in the language. Users who would want to extend coroutines or build their own for various reasons can only do so in ways offered by the language. Furthermore, implementing coroutines without language supports also displays the power of \CFA.
+While this is ultimately the option used for idiomatic \CFA code, coroutines and threads can both be constructed by users without using the language support. The reserved keywords are only present to improve ease of use for the common cases.
+coroutine Fibonacci {
+        int fn; //used for communication
+};
+\end{cfacode}
+This mean the compiler can solve problems by injecting code where needed. The downside of this approach is that it makes coroutine a special case in the language. Users who would want to extend coroutines or build their own for various reasons can only do so in ways offered by the language. Furthermore, implementing coroutines without language supports also displays the power of the programming language used. While this is ultimately the option used for idiomatic \CFA code, coroutines and threads can both be constructed by users without using the language support. The reserved keywords are only present to improve ease of use for the common cases.
 \subsection{Alternative: Lamda Objects}
 …
       coroutine_desc * get_coroutine(T & this);
 };
+\end{cfacode}
+This ensures an object is not a coroutine until \code{resume} (or \code{prime}) is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory foot print of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
+forall( dtype T | is_coroutine(T) ) void suspend(T &);
+forall( dtype T | is_coroutine(T) ) void resume (T &);
+\end{cfacode}
+This ensures an object is not a coroutine until \code{resume} is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory layout of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
 \begin{center}
 …
 \end{center}
 The combination of these two approaches allows users new to concurrency to have a easy and concise method while more advanced users can expose themselves to otherwise hidden pitfalls at the benefit of tighter control on memory layout and initialization.
+The combination of these two approaches allows users new to coroutinning and concurrency to have an easy and concise specification, while more advanced users have tighter control on memory layout and initialization.
 \section{Thread Interface}\label{threads}
 …
 \begin{cfacode}
         thread foo {};
+thread foo {};
 \end{cfacode}
 …
 \end{cfacode}
+Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is possible naturally extend the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
+\begin{cfacode}
+        thread foo {};
+        void main(foo & this) {
+                sout | "Hello World!" | endl;
+        }
+\end{cfacode}
+In this example, threads of type \code{foo} start execution in the \code{void main(foo*)} routine which prints \code{"Hello World!"}. While this proposoal encourages this approach to enforce strongly-typed programming, users may prefer to use the routine based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously
+\begin{cfacode}
+        typedef void (*voidFunc)(void);
+        thread FuncRunner {
+                voidFunc func;
+        };
+        //ctor
+        void ?{}(FuncRunner & this, voidFunc inFunc) {
+                this.func = inFunc;
+        }
+        //main
+        void main(FuncRunner & this) {
+                this.func();
+        }
+\end{cfacode}
+An advantage of the overloading approach to main is to clearly highlight where and what memory is required to pass parameters and return values to/from a thread.
+Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is unnecessary. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs.
+Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is a natural extension of the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
+\begin{cfacode}
+thread foo {};
+void main(foo & this) {
+        sout | "Hello World!" | endl;
+}
+\end{cfacode}
+In this example, threads of type \code{foo} start execution in the \code{void main(foo &)} routine, which prints \code{"Hello World!"}. While this thesis encourages this approach to enforce strongly-typed programming, users may prefer to use the routine-based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as a parameter and executes it on its stack asynchronously
+\begin{cfacode}
+typedef void (*voidFunc)(int);
+thread FuncRunner {
+        voidFunc func;
+        int arg;
+};
+void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
+        this.func = inFunc;
+}
+void main(FuncRunner & this) {
+        this.func( this.arg );
+}
+\end{cfacode}
+An consequence of the strongly typed approach to main is that memory layout of parameters and return values to/from a thread are now explicitly specified in the \acrshort{api}.
+Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is unnecessary. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} after the constructor has completed and \code{join} before the destructor runs.
 \begin{cfacode}
 thread World;
 …
 \end{cfacode}
 This semantic has several advantages over explicit semantics typesafety is guaranteed, a thread is always started and stopped exaclty once and users cannot make any progamming errors. Another advantage of this semantic is that it naturally scale to multiple threads meaning basic synchronisation is very simple
+This semantic has several advantages over explicit semantics: a thread is always started and stopped exaclty once and users cannot make any progamming errors and it naturally scales to multiple threads meaning basic synchronisation is very simple
 \begin{cfacode}
 …
 \end{cfacode}
 However, one of the apparent drawbacks of this system is that threads now always form a lattice, that is they are always destroyed in opposite order of construction because of block structure. However, storage allocation is not limited to blocks; dynamic allocation can create threads that outlive the scope in which the thread is created much like dynamically allocating memory lets objects outlive the scope in which they are created
+However, one of the drawbacks of this approach is that threads now always form a lattice, that is they are always destroyed in opposite order of construction because of block structure. This restriction is relaxed by using dynamic allocation, so threads can outlive the scope in which they are created, much like dynamically allocating memory lets objects outlive the scope in which they are created
 \begin{cfacode}
 …
 };
-//main
 void main(MyThread & this) {
         //...
 …
         MyThread * long_lived;
+        {
+                //Start a thread at the beginning of the scope
                 MyThread short_lived;
-                //Start a thread at the beginning of the scope
-                DoStuff();
                 //create another thread that will outlive the thread in this scope
                 long_lived = new MyThread;
+                DoStuff();
                 //Wait for the thread short_lived to finish
+        }
         DoMoreStuff();
         //Now wait for the short_lived to finish
+        //Now wait for the long_lived to finish
         delete long_lived;
+}

doc/proposals/concurrency/text/cforall.tex

-              rb96ec83
+              r6840e7c
 % ======================================================================
 As mentionned in the introduction, the document presents the design for the concurrency features in \CFA. Since it is a new language here is a quick review of the language specifically tailored to the features needed to support concurrency.
+This thesis presents the design for a set of concurrency features in \CFA. Since it is a new dialect of C, the following is a quick introduction to the language, specifically tailored to the features needed to support concurrency.
 \CFA is a extension of ISO C and therefore supports much of the same paradigms as C. It is a non-object oriented system level language, meaning it has very most of the major abstractions have either no runtime cost or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over assembly. The vast majority of the code produced by a \CFA compiler respects memory-layouts and calling-conventions laid out by C. However, while \CFA is not an object-oriented language according to a strict definition. It does have some notion of objects, most importantly construction and destruction of objects. Most of the following pieces of code can be found as is on the \CFA website : \cite{www-cfa}
+\CFA is a extension of ISO-C and therefore supports all of the same paradigms as C. It is a non-object oriented system language, meaning most of the major abstractions have either no runtime overhead or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over machine code. The vast majority of the code produced by the \CFA translator respects memory-layouts and calling-conventions laid out by C. Interestingly, while \CFA is not an object-oriented language, lacking the concept of a received (e.g.: this), it does have some notion of objects\footnote{C defines the term objects as : [Where to I get the C11 reference manual?]}, most importantly construction and destruction of objects. Most of the following pieces of code can be found on the \CFA website \cite{www-cfa}
 \section{References}
 Like \CC, \CFA introduces references as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references aren't particularly relevant but since this document uses mostly references here is a quick overview of the semantics :
+Like \CC, \CFA introduces references as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references are not particularly relevant but since this document uses mostly references here is a quick overview of the semantics :
 \begin{cfacode}
 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
+*p3   = ...;                                            //change p2
+int y, z, & ar[3] = {x, y, z};          //initialize array of references
+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.
 …
 \section{Overloading}
 Another important feature \CFA has in common with \CC is function overloading :
+Another important feature of \CFA is function overloading as in Java and \CC, where routine with the same name are selected based on the numbers and type of the arguments. As well, \CFA uses the return type as part of the selection criteria, as in Ada\cite{Ada}. For routines with multiple parameters and returns, the selection is complex.
 \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)
+//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)
+// 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)
+//selection based on  type and number of returns
+char   f(int);                  //(1)
+double f(int);                  //(2)
+char   c = f(3);                //select (1)
+double d = f(4);                //select (2)
 \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.
+This feature is particularly important for concurrency since the runtime system relies on creating different types to represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent name clashes. As seen in chapter \ref{basics}, routines main is an example that benefits from overloading.
 \section{Operators}
 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
         return (S){ op1.i + op2.i, op1.j + op2.j };
+struct S {int i, j;};
+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 }
+S s1 = {1, 2}, s2 = {2, 3}, s3;
+s3 = s1 + s2;                                           //compute sum: s3 == {2, 5}
 \end{cfacode}
+Since concurrency does not use operator overloading, this feature is more important as an introduction for the syntax of constructors.
+While concurrency does not use operator overloading directly, this feature is more important as an introduction for the syntax of constructors.
 \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 and destructors are a core feature 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
         ia = calloc( size, sizeof( S ) );
+void ?{}(S & s, int asize) {    //constructor operator
+        s.size = asize;                         //initialize fields
+        s.ia = calloc(size, sizeof(S));
+}
 void ^?{}( S & s ) with s {                     // destructor operator
         free( ia );                             // de-initialization fields
+void ^?{}(S & 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.
+The language guarantees that every object and all their fields are constructed. Like \CC, construction of an object is automatically done on allocation and destruction of the object is done on deallocation. Allocation and deallocation can occur on the stack or on the heap.
+\begin{cfacode}
+{
+        struct S s = {10};      //allocation, call constructor
+        ...
+}                                               //deallocation, call destructor
+struct S * s = new();   //allocation, call constructor
+...
+delete(s);                              //deallocation, call destructor
+\end{cfacode}
+Note that like \CC, \CFA introduces \code{new} and \code{delete}, which behave like \code{malloc} and \code{free} in addition to constructing and destructing objects, after calling \code{malloc} and before calling \code{free} respectively.
+For more information see \cite{cforall-ug,rob-thesis,www-cfa}.
+\section{Parametric Polymorphism}
+Routines in \CFA can also be reused for multiple types. This is done using the \code{forall} clause which gives \CFA it's name. \code{forall} clauses allow seperatly compiled routines to support generic usage over multiple types. For example, the following sum function will work for any type which support construction from 0 and addition :
+\begin{cfacode}
+//constraint type, 0 and +
+forall(otype T | { void ?{}(T *, zero_t); T ?+?(T, T); })
+T sum(T a[ ], size_t size) {
+        T total = 0;                            //construct T from 0
+        for(size_t i = 0; i < size; i++)
+                total = total + a[i];   //select appropriate +
+        return total;
+}
+S sa[5];
+int i = sum(sa, 5);                             //use S's 0 construction and +
+\end{cfacode}
+Since writing constraints on types can become cumbersome for more constrained functions, \CFA also has the concept of traits. Traits are named collection of constraints which can be used both instead and in addition to regular constraints:
+\begin{cfacode}
+trait sumable( otype T ) {
+        void ?{}(T *, zero_t);          //constructor from 0 literal
+        T ?+?(T, T);                            //assortment of additions
+        T ?+=?(T *, T);
+        T ++?(T *);
+        T ?++(T *);
+};
+forall( otype T | sumable(T) )  //use trait
+T sum(T a[], size_t size);
+\end{cfacode}
+\section{with Clause/Statement}
+Since \CFA lacks the concept of a receiver, certain functions end-up needing to repeat variable names often, to solve this \CFA offers the \code{with} statement which opens an aggregate scope making its fields directly accessible (like Pascal).
+\begin{cfacode}
+struct S { int i, j; };
+int mem(S & this) with this             //with clause
+        i = 1;                                          //this->i
+        j = 2;                                          //this->j
+}
+int foo() {
+        struct S1 { ... } s1;
+        struct S2 { ... } s2;
+        with s1                                         //with statement
+        {
+                //access fields of s1
+                //without qualification
+                with s2                                 //nesting
+                {
+                        //access fields of s1 and s2
+                        //without qualification
+                }
+        }
+        with s1, s2                             //scopes open in parallel
+        {
+                //access fields of s1 and s2
+                //without qualification
+        }
+}
+\end{cfacode}
+For more information on \CFA see \cite{cforall-ug,rob-thesis,www-cfa}.

doc/proposals/concurrency/text/concurrency.tex

-              rb96ec83
+              r6840e7c
 % ======================================================================
 % ======================================================================
 Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
+Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
 Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}.
 An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA.
 One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
+An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for systems language, which is why it was rejected as the core paradigm for concurrency in \CFA.
+One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared-memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
 \section{Basics}
 Non-determinism requires concurrent systems to offer support for mutual-exclusion and synchronisation. Mutual-exclusion is the concept that only a fixed number of threads can access a critical section at any given time, where a critical section is a group of instructions on an associated portion of data that requires the restricted access. On the other hand, synchronization enforces relative ordering of execution and synchronization tools numerous mechanisms to establish timing relationships among threads.
+Non-determinism requires concurrent systems to offer support for mutual-exclusion and synchronisation. Mutual-exclusion is the concept that only a fixed number of threads can access a critical section at any given time, where a critical section is a group of instructions on an associated portion of data that requires the restricted access. On the other hand, synchronization enforces relative ordering of execution and synchronization tools provide numerous mechanisms to establish timing relationships among threads.
 \subsection{Mutual-Exclusion}
 As mentionned above, mutual-exclusion is the guarantee that only a fix number of threads can enter a critical section at once. However, many solution exists for mutual exclusion which vary in terms of performance, flexibility and ease of use. Methods range from low-level locks, which are fast and flexible but require significant attention to be correct, to  higher-level mutual-exclusion methods, which sacrifice some performance in order to improve ease of use. Ease of use comes by either guaranteeing some problems cannot occur (e.g., being deadlock free) or by offering a more explicit coupling between data and corresponding critical section. For example, the \CC \code{std::atomic<T>} which offer an easy way to express mutual-exclusion on a restricted set of operations (.e.g: reading/writing large types atomically). Another challenge with low-level locks is composability. Locks are not composable because it takes careful organising for multiple locks to be used while preventing deadlocks. Easing composability is another feature higher-level mutual-exclusion mechanisms often offer.
+As mentionned above, mutual-exclusion is the guarantee that only a fix number of threads can enter a critical section at once. However, many solutions exist for mutual exclusion, which vary in terms of performance, flexibility and ease of use. Methods range from low-level locks, which are fast and flexible but require significant attention to be correct, to  higher-level mutual-exclusion methods, which sacrifice some performance in order to improve ease of use. Ease of use comes by either guaranteeing some problems cannot occur (e.g., being deadlock free) or by offering a more explicit coupling between data and corresponding critical section. For example, the \CC \code{std::atomic<T>} offers an easy way to express mutual-exclusion on a restricted set of operations (e.g.: reading/writing large types atomically). Another challenge with low-level locks is composability. Locks have restricted composability because it takes careful organising for multiple locks to be used while preventing deadlocks. Easing composability is another feature higher-level mutual-exclusion mechanisms often offer.
 \subsection{Synchronization}
 As for mutual-exclusion, low level synchronisation primitive often offer good performance and good flexibility at the cost of ease of use. Again, higher-level mechanism often simplify usage by adding better coupling between synchronization and data, .eg., message passing, or offering simple solution to otherwise involved challenges. An example of this is barging. As mentionned above synchronization can be expressed as guaranteeing that event \textit{X} always happens before \textit{Y}. Most of the time synchronisation happens around a critical section, where threads most acquire said critical section in a certain order. However, it may also be desired to be able to guarantee that event \textit{Z} does not occur between \textit{X} and \textit{Y}. This is called barging, where event \textit{X} tries to effect event \textit{Y} but anoter thread races to grab the critical section and emits \textit{Z} before \textit{Y}. Preventing or detecting barging is an involved challenge with low-level locks, which can be made much easier by higher-level constructs.
+As for mutual-exclusion, low-level synchronisation primitives often offer good performance and good flexibility at the cost of ease of use. Again, higher-level mechanism often simplify usage by adding better coupling between synchronization and data, e.g.: message passing, or offering simple solution to otherwise involved challenges. An example is barging. As mentioned above, synchronization can be expressed as guaranteeing that event \textit{X} always happens before \textit{Y}. Most of the time, synchronisation happens around a critical section, where threads must acquire critical sections in a certain order. However, it may also be desirable to guarantee that event \textit{Z} does not occur between \textit{X} and \textit{Y}. Not satisfying this property called barging. For example, where event \textit{X} tries to effect event \textit{Y} but another thread acquires the critical section and emits \textit{Z} before \textit{Y}. Preventing or detecting barging is an involved challenge with low-level locks, which can be made much easier by higher-level constructs. This challenge is often split into two different methods, barging avoidance and barging prevention. Algorithms that use status flags and other flag variables to detect barging threads are said to be using barging avoidance while algorithms that baton-passing locks between threads instead of releasing the locks are said to be using barging prevention.
 % ======================================================================
 …
 A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java~\cite{Java} or \uC~\cite{uC++book} but does not strictly require OO semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it :
 \begin{cfacode}
         typedef /*some monitor type*/ monitor;
         int f(monitor & m);
         int main() {
                 monitor m;  //Handle m
                 f(m);       //Routine using handle
+        }
+typedef /*some monitor type*/ monitor;
+int f(monitor & m);
+int main() {
+        monitor m;  //Handle m
+        f(m);       //Routine using handle
+}
 \end{cfacode}
 …
 \begin{cfacode}
+        monitor counter_t { /*...see section $\ref{data}$...*/ };
+        void ?{}(counter_t & nomutex this); //constructor
+        size_t ++?(counter_t & mutex this); //increment
+        //need for mutex is platform dependent
+        void ?{}(size_t * this, counter_t & mutex cnt); //conversion
+\end{cfacode}
+Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual-exclusion when constructing. This semantics is because an object not yet constructed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} keyword depending on whether or not reading an \code{size_t} is an atomic operation.
+Having both \code{mutex} and \code{nomutex} keywords is redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without qualifiers \code{void foo(counter_t & this)}, then it is reasonable that it should default to the safest option \code{mutex}, whereas assuming \code{nomutex} is unsafe and may cause subtle errors. In fact, \code{nomutex} is the "normal" parameter behaviour, with the \code{nomutex} keyword effectively stating explicitly that "this routine is not special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routines neither keyword. Mandatory keywords would also have the added benefit of being self-documented but at the cost of extra typing. While there are several benefits to mandatory keywords, they do bring a few challenges. Mandatory keywords in \CFA would imply that the compiler must know without a doubt wheter or not a parameter is a monitor or not. Since \CFA relies heavily on traits as an abstraction mechanism, the distinction between a type that is a monitor and a type that looks like a monitor can become blurred. For this reason, \CFA only has the \code{mutex} keyword.
+The next semantic decision is to establish when \code{mutex} may be used as a type qualifier. Consider the following declarations:
+\begin{cfacode}
+int f1(monitor & mutex m);
+int f2(const monitor & mutex m);
+int f3(monitor ** mutex m);
+int f4(monitor * mutex m []);
+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:
+\begin{cfacode}
+int f1(monitor & mutex m);   //Okay : recommanded case
+int f2(monitor * mutex m);   //Okay : could be an array but probably not
+int f3(monitor mutex m []);  //Not Okay : Array of unkown length
+int f4(monitor ** mutex m);  //Not Okay : Could be an array
+int f5(monitor * mutex m []); //Not Okay : Array of unkown length
+\end{cfacode}
+Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends naturally to multi-monitor calls.
+\begin{cfacode}
+int f(MonitorA & mutex a, MonitorB & mutex b);
+MonitorA a;
+MonitorB b;
+f(a,b);
+\end{cfacode}
+The capacity to acquire multiple locks before entering a critical section is called \emph{\gls{group-acquire}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use multi-acquisition locks, users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order:
+\begin{cfacode}
+        void foo(A & mutex a, B & mutex b) { //acquire a & b
+                ...
+        }
+        void bar(A & mutex a, B & /*nomutex*/ b) { //acquire a
+                ... foo(a, b); ... //acquire b
+        }
+        void baz(A & /*nomutex*/ a, B & mutex b) { //acquire b
+                ... foo(a, b); ... //acquire a
+        }
+\end{cfacode}
+The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
+However, such use leads the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires:
+\begin{enumerate}
+        \item Dynamically tracking of the monitor-call order.
+        \item Implement rollback semantics.
+\end{enumerate}
+While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA, users simply need to be carefull when acquiring multiple monitors at the same time.
+Finally, for convenience, monitors support multiple acquiring, that is acquiring a monitor while already holding it does not cause a deadlock. It simply increments an internal counter which is then used to release the monitor after the number of acquires and releases match up. This is particularly usefull when monitor routines use other monitor routines as helpers or for recursions. For example:
+\begin{cfacode}
+monitor bank {
+        int money;
+        log_t usr_log;
+};
+void deposit( bank & mutex b, int deposit ) {
+        b.money += deposit;
+        b.usr_log | "Adding" | deposit | endl;
+}
+void transfer( bank & mutex mybank, bank & mutex yourbank, int me2you) {
+        deposit( mybank, -me2you );
+        deposit( yourbank, me2you );
+}
+\end{cfacode}
+% ======================================================================
+% ======================================================================
+\subsection{Data semantics} \label{data}
+% ======================================================================
+% ======================================================================
+Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contain shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
+\begin{cfacode}
+monitor counter_t {
+        int value;
+};
+void ?{}(counter_t & this) {
+        this.cnt = 0;
+}
+int ?++(counter_t & mutex this) {
+        return ++this.value;
+}
+//need for mutex is platform dependent here
+void ?{}(int * this, counter_t & mutex cnt) {
+        *this = (int)cnt;
+}
+\end{cfacode}
+monitor counter_t { /*...see section $\ref{data}$...*/ };
+void ?{}(counter_t & nomutex this); //constructor
+size_t ++?(counter_t & mutex this); //increment
+//need for mutex is platform dependent
+void ?{}(size_t * this, counter_t & mutex cnt); //conversion
+\end{cfacode}
 This counter is used as follows:
 \begin{center}
 …
 Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting.
+% ======================================================================
+% ======================================================================
+\subsection{Implementation Details: Interaction with polymorphism}
+% ======================================================================
+% ======================================================================
+Depending on the choice of semantics for when monitor locks are acquired, interaction between monitors and \CFA's concept of polymorphism can be complex to support. However, it is shown that entry-point locking solves most of the issues.
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines.
+Before looking into complex control-flow, it is important to present the difference between the two acquiring options : callsite and entry-point locking, i.e. acquiring the monitors before making a mutex routine call or as the first operation of the mutex routine-call. For example:
+Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual-exclusion when constructing. This semantics is because an object not yet constructed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} keyword depending on whether or not reading a \code{size_t} is an atomic operation.
+For maximum usability, monitors use \gls{multi-acq} semantics, which means a single thread can acquire multiple times the same monitor without deadlock. For example, figure \ref{fig:search} uses recursion and \gls{multi-acq} to print values inside a binary tree.
+\begin{figure}
+\label{fig:search}
+\begin{cfacode}
+monitor printer { ... };
+struct tree {
+        tree * left, right;
+        char * value;
+};
+void print(printer & mutex p, char * v);
+void print(printer & mutex p, tree * t) {
+        print(p, t->value);
+        print(p, t->left );
+        print(p, t->right);
+}
+\end{cfacode}
+\caption{Recursive printing algorithm using \gls{multi-acq}.}
+\end{figure}
+Having both \code{mutex} and \code{nomutex} keywords is redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without qualifiers \code{void foo(counter_t & this)}, then it is reasonable that it should default to the safest option \code{mutex}, whereas assuming \code{nomutex} is unsafe and may cause subtle errors. In fact, \code{nomutex} is the "normal" parameter behaviour, with the \code{nomutex} keyword effectively stating explicitly that "this routine is not special". Another alternative is making exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routines with neither keyword. Mandatory keywords would also have the added benefit of being self-documented but at the cost of extra typing. While there are several benefits to mandatory keywords, they do bring a few challenges. Mandatory keywords in \CFA would imply that the compiler must know without doubt whether or not a parameter is a monitor or not. Since \CFA relies heavily on traits as an abstraction mechanism, the distinction between a type that is a monitor and a type that looks like a monitor can become blurred. For this reason, \CFA only has the \code{mutex} keyword and uses no keyword to mean \code{nomutex}.
+The next semantic decision is to establish when \code{mutex} may be used as a type qualifier. Consider the following declarations:
+\begin{cfacode}
+int f1(monitor & mutex m);
+int f2(const monitor & mutex m);
+int f3(monitor ** mutex m);
+int f4(monitor * mutex m []);
+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 problem can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, this project imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with at most 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. 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}
+int f1(monitor & mutex m);   //Okay : recommanded case
+int f2(monitor * mutex m);   //Okay : could be an array but probably not
+int f3(monitor mutex m []);  //Not Okay : Array of unkown length
+int f4(monitor ** mutex m);  //Not Okay : Could be an array
+int f5(monitor * mutex m []); //Not Okay : Array of unkown length
+\end{cfacode}
+Note that not all array functions are actually distinct in the type system sense. However, even the code generation could tell the difference, the extra information is still not sufficient to extend meaningfully the monitor call semantic.
+Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion often receives an object, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends naturally to multi-monitor calls.
+\begin{cfacode}
+int f(MonitorA & mutex a, MonitorB & mutex b);
+MonitorA a;
+MonitorB b;
+f(a,b);
+\end{cfacode}
+The capacity to acquire multiple locks before entering a critical section is called \emph{\gls{bulk-acq}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use \gls{multi-acq} locks, users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order:
+\begin{cfacode}
+void foo(A & mutex a, B & mutex b) { //acquire a & b
+        ...
+}
+void bar(A & mutex a, B & /*nomutex*/ b) { //acquire a
+        ... foo(a, b); ... //acquire b
+}
+void baz(A & /*nomutex*/ a, B & mutex b) { //acquire b
+        ... foo(a, b); ... //acquire a
+}
+\end{cfacode}
+The \gls{multi-acq} monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
+However, such use leads to the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires:
+\begin{enumerate}
+        \item Dynamically tracking of the monitor-call order.
+        \item Implement rollback semantics.
+\end{enumerate}
+While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA, users simply need to be carefull when acquiring multiple monitors at the same time or only use \gls{bulk-acq} of all the monitors.
+\Gls{multi-acq} and \gls{bulk-acq} can be used together in interesting ways, for example:
+\begin{cfacode}
+monitor bank { ... };
+void deposit( bank & mutex b, int deposit );
+void transfer( bank & mutex mybank, bank & mutex yourbank, int me2you) {
+        deposit( mybank, -me2you );
+        deposit( yourbank, me2you );
+}
+\end{cfacode}
+This example shows a trivial solution to the bank account transfer problem\cit. Without \gls{multi-acq} and \gls{bulk-acq}, the solution to this problem is much more involved and requires carefull engineering.
+\subsubsection{\code{mutex} statement} \label{mutex-stmt}
+The call semantics discussed aboved have one software engineering issue, only a named routine can acquire the mutual-exclusion of a set of monitor. \CFA offers the \code{mutex} statement to workaround the need for unnecessary names, avoiding a major software engineering problem\cit. Listing \ref{lst:mutex-stmt} shows an example of the \code{mutex} statement, which introduces a new scope in which the mutual-exclusion of a set of monitor is acquired. Beyond naming, the \code{mutex} statement has no semantic difference from a routine call with \code{mutex} parameters.
+\begin{figure}
 \begin{center}
+\setlength\tabcolsep{1.5pt}
+\begin{tabular}{|c|c|c|}
+Code & \gls{callsite-locking} & \gls{entry-point-locking} \\
+\CFA & pseudo-code & pseudo-code \\
+\begin{tabular}{|c|c|}
+function call & \code{mutex} statement \\
 \hline
 \begin{cfacode}[tabsize=3]
+void foo(monitor& mutex a){
+        //Do Work
+        //...
+}
+void main() {
+        monitor a;
+        foo(a);
+}
+\end{cfacode} & \begin{pseudo}[tabsize=3]
+foo(& a) {
+        //Do Work
+        //...
+}
+main() {
+        monitor a;
+        //calling routine
+        //handles concurrency
+        acquire(a);
+        foo(a);
+        release(a);
+}
+\end{pseudo} & \begin{pseudo}[tabsize=3]
+foo(& a) {
+        //called routine
+        //handles concurrency
+        acquire(a);
+        //Do Work
+        //...
+        release(a);
+}
+main() {
+        monitor a;
+        foo(a);
+}
+\end{pseudo}
+monitor M {};
+void foo( M & mutex m ) {
+        //critical section
+}
+void bar( M & m ) {
+        foo( m );
+}
+\end{cfacode}&\begin{cfacode}[tabsize=3]
+monitor M {};
+void bar( M & m ) {
+        mutex(m) {
+                //critical section
+        }
+}
+\end{cfacode}
 \end{tabular}
 \end{center}
+\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
+Note the \code{mutex} keyword relies on the resolver, which means that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
+\begin{cfacode}
+//Incorrect
+//T is not a monitor
+forall(dtype T)
+void foo(T * mutex t);
+//Correct
+//this function only works on monitors
+//(any monitor)
+forall(dtype T | is_monitor(T))
+void bar(T * mutex t));
+\caption{Regular call semantics vs. \code{mutex} statement}
+\label{lst:mutex-stmt}
+\end{figure}
+% ======================================================================
+% ======================================================================
+\subsection{Data semantics} \label{data}
+% ======================================================================
+% ======================================================================
+Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contain shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
+\begin{cfacode}
+monitor counter_t {
+        int value;
+};
+void ?{}(counter_t & this) {
+        this.cnt = 0;
+}
+int ?++(counter_t & mutex this) {
+        return ++this.value;
+}
+//need for mutex is platform dependent here
+void ?{}(int * this, counter_t & mutex cnt) {
+        *this = (int)cnt;
+}
 \end{cfacode}
 …
 % ======================================================================
 % ======================================================================
 In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this is generally achieved with internal or external scheduling as in\cit. Since internal scheduling of single monitors is mostly a solved problem, this proposal concentraits on extending internal scheduling to multiple monitors at once. Indeed, like the \gls{group-acquire} semantics, internal scheduling extends to multiple monitors at once in a way that is natural to the user but requires additional complexity on the implementation side.
+In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this capability is generally achieved with internal or external scheduling as in\cit. Since internal scheduling within a single monitor is mostly a solved problem, this thesis concentrates on extending internal scheduling to multiple monitors. Indeed, like the \gls{bulk-acq} semantics, internal scheduling extends to multiple monitors in a way that is natural to the user but requires additional complexity on the implementation side.
 First, here is a simple example of such a technique:
 \begin{cfacode}
         monitor A {
                 condition e;
+        }
         void foo(A & mutex a) {
                 ...
                 // Wait for cooperation from bar()
                 wait(a.e);
                 ...
+        }
         void bar(A & mutex a) {
                 // Provide cooperation for foo()
                 ...
                 // Unblock foo at scope exit
                 signal(a.e);
+        }
 \end{cfacode}
 There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
 An important aspect to take into account here is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
+monitor A {
+        condition e;
+}
+void foo(A & mutex a) {
+        ...
+        //Wait for cooperation from bar()
+        wait(a.e);
+        ...
+}
+void bar(A & mutex a) {
+        //Provide cooperation for foo()
+        ...
+        //Unblock foo
+        signal(a.e);
+}
+\end{cfacode}
+There are two details to note here. First, the \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This semantic is needed to respect mutual-exclusion. Second, in \CFA, a \code{condition} variable can be stored/created independently of a monitor. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
+An important aspect of the implementation is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
 % ======================================================================
 …
 % ======================================================================
 % ======================================================================
 It is easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors.
+It is easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors. Indeed, \code{wait} statements always use a single condition as paremeter and waits on the monitors associated with the condition.
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
 The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention.
 A direct extension of the previous example is the \gls{group-acquire} version:
+The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. It is important to note here that both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This semantic is a logical requirement for barging prevention.
+A direct extension of the previous example is a \gls{bulk-acq} version:
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
+This version uses \gls{group-acquire} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
+While deadlock issues can occur when nesting monitors, these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable. However, for monitors as for locks, it is possible to write a program using nesting without encountering any problems if nested is done correctly. For example, the next pseudo-code snippet acquires monitors A then B before waiting while only acquiring B when signalling, effectively avoiding the nested monitor problem.
+This version uses \gls{bulk-acq} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
+While deadlock issues can occur when nesting monitors, these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable. For monitors, a well known deadlock problem is the Nested Monitor Problem\cit, which occurs when a \code{wait} is made on a thread that holds more than one monitor. For example, the following pseudo-code will run into the nested monitor problem :
 \begin{multicols}{2}
 \begin{pseudo}
 …
 \begin{pseudo}
+acquire A
+        acquire B
+                signal B
+        release B
+release A
+\end{pseudo}
+\end{multicols}
+However, for monitors as for locks, it is possible to write a program using nesting without encountering any problems if nesting is done correctly. For example, the next pseudo-code snippet acquires monitors {\sf A} then {\sf B} before waiting, while only acquiring {\sf B} when signalling, effectively avoiding the nested monitor problem.
+\begin{multicols}{2}
+\begin{pseudo}
+acquire A
+        acquire B
+                wait B
+        release B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
 acquire B
 …
 \end{multicols}
+The next example is where \gls{group-acquire} adds a significant layer of complexity to the internal signalling semantics.
+Listing \ref{lst:int-bulk-pseudo} shows an example where \gls{bulk-acq} adds a significant layer of complexity to the internal signalling semantics. Listing \ref{lst:int-bulk-cfa} shows the corresponding \CFA code which implements the pseudo-code in listing \ref{lst:int-bulk-pseudo}. Note that listing \ref{lst:int-bulk-cfa} uses non-\code{mutex} parameter to introduce monitor \code{b} into context. However, for the purpose of translating the given pseudo-code into \CFA-code any method of introducing new monitors into context, other than a \code{mutex} parameter, is acceptable, e.g. global variables, pointer parameters or using locals with the \code{mutex}-statement.
+\begin{figure}[!b]
 \begin{multicols}{2}
 Waiting thread
 \begin{pseudo}[numbers=left]
 acquire A
         // Code Section 1
+        //Code Section 1
         acquire A & B
                 // Code Section 2
+                //Code Section 2
                 wait A & B
                 // Code Section 3
+                //Code Section 3
         release A & B
         // Code Section 4
+        //Code Section 4
 release A
 \end{pseudo}
 …
 \begin{pseudo}[numbers=left, firstnumber=10]
 acquire A
         // Code Section 5
+        //Code Section 5
         acquire A & B
                 // Code Section 6
+                //Code Section 6
                 signal A & B
                 // Code Section 7
+                //Code Section 7
         release A & B
+        // Code Section 8
+release A
+\end{pseudo}
+\end{multicols}
+\begin{center}
+Listing 1
+\end{center}
+It is particularly important to pay attention to code sections 8 and 4, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
+        //Code Section 8
+release A
+\end{pseudo}
+\end{multicols}
+\caption{Internal scheduling with \gls{bulk-acq}}
+\label{lst:int-bulk-pseudo}
+\end{figure}
+\begin{figure}[!b]
+\begin{multicols}{2}
+Waiting thread
+\begin{cfacode}
+monitor A;
+monitor B;
+extern condition c;
+void foo(A & mutex a, B & b) {
+        //Code Section 1
+        mutex(a, b) {
+                //Code Section 2
+                wait(c);
+                //Code Section 3
+        }
+        //Code Section 4
+}
+\end{cfacode}
+\columnbreak
+Signalling thread
+\begin{cfacode}
+monitor A;
+monitor B;
+extern condition c;
+void foo(A & mutex a, B & b) {
+        //Code Section 5
+        mutex(a, b) {
+                //Code Section 6
+                signal(c);
+                //Code Section 7
+        }
+        //Code Section 8
+}
+\end{cfacode}
+\end{multicols}
+\caption{Equivalent \CFA code for listing \ref{lst:int-bulk-pseudo}}
+\label{lst:int-bulk-cfa}
+\end{figure}
+It is particularly important to pay attention to code sections 4 and 8, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{bulk-acq} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options.
 \subsubsection{Delaying signals}
 The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed because this semantics fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of object, effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
+The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed because this semantics fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of objects, effectively making the existing single monitor semantic viable by simply changing monitors to monitor groups.
 \begin{multicols}{2}
 Waiter
 …
 \end{pseudo}
 \end{multicols}
+However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
+\newpage
+However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents signalling monitor A on a different condition variable:
 \begin{multicols}{2}
 Thread 1
 …
 Thread 3
 \begin{pseudo}[numbers=left, firstnumber=10]
+\begin{pseudo}[numbers=left, firstnumber=9]
 acquire A
         acquire A & B
 …
 Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
 In both cases, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
+In both cases, the threads need to be able to distinguish, on a per monitor basis, which ones need to be released and which ones need to be transferred, which means monitors cannot be handled as a single homogenous group and therefore invalidates the main benefit of this approach.
 \subsubsection{Dependency graphs}
 In the Listing 1 pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
+In the Listing 1 pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it, then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
+Resolving dependency graph being a complex and expensive endeavour, this solution is not the preffered one.
+\subsubsection{Partial signalling} \label{partial-sig}
+Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
+\begin{multicols}{2}
+\begin{pseudo}[numbers=left]
+\begin{figure}
+\begin{multicols}{3}
+Thread $\alpha$
+\begin{pseudo}[numbers=left, firstnumber=1]
 acquire A
         acquire A & B
 …
 \columnbreak
+\begin{pseudo}[numbers=left, firstnumber=6]
+Thread $\gamma$
+\begin{pseudo}[numbers=left, firstnumber=1]
 acquire A
         acquire A & B
                 signal A & B
         release A & B
+        // ... More code
+release A
+\end{pseudo}
+\end{multicols}
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
+        signal A
+release A
+\end{pseudo}
+\columnbreak
+Thread $\beta$
+\begin{pseudo}[numbers=left, firstnumber=1]
+acquire A
+        wait A
+release A
+\end{pseudo}
+\end{multicols}
+\caption{Dependency graph}
+\label{lst:dependency}
+\end{figure}
+\begin{figure}
+\begin{center}
+\input{dependency}
+\end{center}
+\label{fig:dependency}
+\caption{Dependency graph of the statements in listing \ref{lst:dependency}}
+\end{figure}
+Listing \ref{lst:dependency} is the three thread example rewritten for dependency graphs as well as the corresponding dependency graph. Figure \ref{fig:dependency} shows the corresponding dependency graph that results, where every node is a statement of one of the three threads, and the arrows the dependency of that statement. The extra challenge is that this dependency graph is effectively post-mortem, but the run time system needs to be able to build and solve these graphs as the dependency unfolds. Resolving dependency graph being a complex and expensive endeavour, this solution is not the preffered one.
+\subsubsection{Partial signalling} \label{partial-sig}
+Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
+\begin{multicols}{2}
+\begin{pseudo}[numbers=left]
+acquire A
+        acquire A & B
+                wait A & B
+        release A & B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}[numbers=left, firstnumber=6]
+acquire A
+        acquire A & B
+                signal A & B
+        release A & B
+        //... More code
+release A
+\end{pseudo}
+\end{multicols}
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionally waking threads if all conditions are met. This solution has a much simpler implementation than a dependency graph solving algorithm which is why it was chosen.
 % ======================================================================
 …
 An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
+For example here is an example highlighting the difference in behaviour:
 \begin{center}
+The example in listing \ref{lst:datingservice} highlights the difference in behaviour. As mentioned, \code{signal} only transfers ownership once the current critical section exits, this behaviour cause the need for additional synchronisation when a two-way handshake is needed. To avoid this extraneous synchronisation, the \code{condition} type offers the \code{signal_block} routine which handle two-way handshakes as shown in the example. This removes the need for a second condition variables and simplifies programming. Like every other monitor semantic, \code{signal_block} uses barging prevention which means mutual-exclusion is baton-passed both on the frond-end and the back-end of the call to \code{signal_block}, meaning no other thread can acquire the monitor neither before nor after the call.
+\begin{figure}
 \begin{tabular}{|c|c|}
 \code{signal} & \code{signal_block} \\
 \hline
+\begin{cfacode}
+monitor M { int val; };
+void foo(M & mutex m ) {
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+        wait( c );
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+}
+void bar(M & mutex m ) {
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+        signal( c );
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+}
+\end{cfacode}&\begin{cfacode}
+monitor M { int val; };
+void foo(M & mutex m ) {
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+        wait( c );
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+}
+void bar(M & mutex m ) {
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+        signal_block( c );
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+\begin{cfacode}[tabsize=3]
+monitor DatingService
+{
+        //compatibility codes
+        enum{ CCodes = 20 };
+        int girlPhoneNo
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+condition exchange;
+int girl(int phoneNo, int ccode)
+{
+        //no compatible boy ?
+        if(empty(boys[ccode]))
+        {
+                //wait for boy
+                wait(girls[ccode]);
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy fron chair
+                signal(exchange);
+        }
+        else
+        {
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy
+                signal(boys[ccode]);
+                //sit in chair
+                wait(exchange);
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int ccode)
+{
+        //same as above
+        //with boy/girl interchanged
+}
+\end{cfacode}&\begin{cfacode}[tabsize=3]
+monitor DatingService
+{
+        //compatibility codes
+        enum{ CCodes = 20 };
+        int girlPhoneNo;
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+//exchange is not needed
+int girl(int phoneNo, int ccode)
+{
+        //no compatible boy ?
+        if(empty(boys[ccode]))
+        {
+                //wait for boy
+                wait(girls[ccode]);
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy fron chair
+                signal(exchange);
+        }
+        else
+        {
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy
+                signal_block(boys[ccode]);
+                //second handshake unnecessary
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int ccode)
+{
+        //same as above
+        //with boy/girl interchanged
+}
 \end{cfacode}
 \end{tabular}
+\end{center}
+Assuming that \code{val} is initialized at 0, that each routine are called from seperate thread and that \code{foo} is always called first. The previous code would yield the following output:
+\begin{center}
+\begin{tabular}{|c|c|}
+\code{signal} & \code{signal_block} \\
+\hline
+\begin{pseudo}
+Foo: 0
+Bar: 1
+Bar: 2
+Foo: 3
+\end{pseudo}&\begin{pseudo}
+Foo: 0
+Bar: 1
+Foo: 2
+Bar: 3
+\end{pseudo}
+\end{tabular}
+\end{center}
+As mentionned, \code{signal} only transfers ownership once the current critical section exits, resulting in the second "Bar" line to be printed before the second "Foo" line. On the other hand, \code{signal_block} immediately transfers ownership to \code{bar}, causing an inversion of output. Obviously this means that \code{signal_block} is a blocking call, which will only be resumed once the signalled function exits the critical section.
+% ======================================================================
+% ======================================================================
+\subsection{Internal scheduling: Implementation} \label{inschedimpl}
+% ======================================================================
+% ======================================================================
+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.
+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.
+Since stack allocation is based around scope, the first step of the implementation is to identify the scopes that are available to store the information, and which of these can have a variable length. In the case of external scheduling, the threads and the condition both allow a fixed amount of memory to be stored, while mutex-routines and the actual blocking call allow for an unbound amount (though adding too much to the mutex routine stack size can become expansive faster).
+The following figure is the traditionnal illustration of a monitor :
+\begin{center}
+{\resizebox{0.4\textwidth}{!}{\input{monitor}}}
+\end{center}
+For \CFA, the previous picture does not have support for blocking multiple monitors on a single condition. To support \gls{group-acquire} two changes to this picture are required. First, it doesn't make sense to tie the condition to a single monitor since blocking two monitors as one would require arbitrarily picking a monitor to hold the condition. Secondly, the object waiting on the conditions and AS-stack cannot simply contain the waiting thread since a single thread can potentially wait on multiple monitors. As mentionned in section \ref{inschedimpl}, the handling in multiple monitors is done by partially passing, which entails that each concerned monitor needs to have a node object. However, for waiting on the condition, since all threads need to wait together, a single object needs to be queued in the condition. Moving out the condition and updating the node types yields :
+\begin{center}
+{\resizebox{0.8\textwidth}{!}{\input{int_monitor}}}
+\end{center}
+\newpage
+This picture and the proper entry and leave algorithms is the fundamental implementation of internal scheduling.
+\begin{multicols}{2}
+Entry
+\begin{pseudo}[numbers=left]
+if monitor is free
+        enter
+elif I already own the monitor
+        continue
+else
+        block
+increment recursion
+\end{pseudo}
+\columnbreak
+Exit
+\begin{pseudo}[numbers=left, firstnumber=8]
+decrement recursion
+if recursion == 0
+        if signal_stack not empty
+                set_owner to thread
+                if all monitors ready
+                        wake-up thread
+        if entry queue not empty
+                wake-up thread
+\end{pseudo}
+\end{multicols}
+Some important things to notice about the exit routine. The solution discussed in \ref{inschedimpl} can be seen on line 11 of the previous pseudo code. Basically, the solution boils down to having a seperate data structure for the condition queue and the AS-stack, and unconditionally transferring ownership of the monitors but only unblocking the thread when the last monitor has trasnferred ownership. This solution is safe as well as preventing any potential barging.
+\caption{Dating service example using \code{signal} and \code{signal_block}. }
+\label{lst:datingservice}
+\end{figure}
 % ======================================================================
 …
 \end{tabular}
 \end{center}
 This method is more constrained and explicit, which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g., \uC) or in terms of data (e.g. Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control-flow semantics were chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The previous example shows a simple use \code{_Accept} versus \code{wait}/\code{signal} and its advantages. Note that while other languages often use \code{accept} as the core external scheduling keyword, \CFA uses \code{waitfor} to prevent name collisions with existing socket APIs.
 In the case of internal scheduling, the call to \code{wait} only guarantees that \code{V} is the last routine to access the monitor. This entails that the routine \code{V} may have acquired mutual exclusion several times while routine \code{P} was waiting. On the other hand, external scheduling guarantees that while routine \code{P} was waiting, no routine other than \code{V} could acquire the monitor.
+This method is more constrained and explicit, which helps users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g., \uC with \code{_Accept}) or in terms of data (e.g. Go with channels). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control-flow semantics were chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The previous example shows a simple use \code{_Accept} versus \code{wait}/\code{signal} and its advantages. Note that while other languages often use \code{accept}/\code{select} as the core external scheduling keyword, \CFA uses \code{waitfor} to prevent name collisions with existing socket \acrshort{api}s.
+In the case of internal scheduling, the call to \code{wait} only guarantees that \code{V} is the last routine to access the monitor. This entails that a third routine, say \code{isInUse()}, may have acquired mutual exclusion several times while routine \code{P} was waiting. On the other hand, external scheduling guarantees that while routine \code{P} was waiting, no routine other than \code{V} could acquire the monitor.
 % ======================================================================
 …
 \begin{cfacode}
+        monitor A {};
+        void f(A & mutex a);
+        void f(int a, float b);
+        void g(A & mutex a) {
+                waitfor(f); // Less obvious which f() to wait for
+        }
+monitor A {};
+void f(A & mutex a);
+void g(A & mutex a) {
+        waitfor(f); //Obvious which f() to wait for
+}
+void f(A & mutex a, int); //New different F added in scope
+void h(A & mutex a) {
+        waitfor(f); //Less obvious which f() to wait for
+}
 \end{cfacode}
 …
         if monitor is free
                 enter
         elif I already own the monitor
+        elif already own the monitor
                 continue
         elif monitor accepts me
 …
 \end{center}
 For the fist two conditions, it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
+For the first two conditions, it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
 \begin{center}
 …
 \end{center}
 There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number (e.g. 128) of mutex members. This technique cannot be used in \CFA because it relies on the fact that the monitor type declares all the acceptable routines. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
 The alternative would be to have a picture more like this one:
+There are other alternatives to these pictures, but in the case of this picture, implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number (e.g. 128) of mutex members. This technique cannot be used in \CFA because it relies on the fact that the monitor type declares all the acceptable routines. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
+The alternative is to have a picture like this one:
 \begin{center}
 …
 \end{center}
 Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to waitfor to check if a routine is already queued in.
 At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. In the end, the most flexible approach has been chosen since it allows users to write programs that would otherwise be prohibitively hard to write. This is based on the assumption that writing fast but inflexible locks is closer to a solved problems than writing locks that are as flexible as external scheduling in \CFA.
 Another aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine are considered as distinct routines. However, this could easily be extended in the future.
+Not storing the mask inside the monitor means that the storage for the mask information can vary between calls to \code{waitfor}, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to waitfor to check if a routine is already queued in.
+Note that in the second picture, tasks need to always keep track of through which routine they are attempting to acquire the monitor and the routine mask needs to have both a function pointer and a set of monitors, as will be discussed in the next section. These details where omitted from the picture for the sake of simplifying the representation.
+At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. In the end, the most flexible approach has been chosen since it allows users to write programs that would otherwise be prohibitively hard to write. This decision is based on the assumption that writing fast but inflexible locks is closer to a solved problems than writing locks that are as flexible as external scheduling in \CFA.
 % ======================================================================
 …
 % ======================================================================
 External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established:
 \begin{cfacode}
         mutex struct A {};
         mutex struct B {};
         void g(A & mutex a, B & mutex b) {
                 waitfor(f); //ambiguous, which monitor
+        }
+External scheduling, like internal scheduling, becomes significantly more complex when introducing multi-monitor syntax. Even in the simplest possible case, some new semantics need to be established:
+\begin{cfacode}
+monitor M {};
+void f(M & mutex a);
+void g(M & mutex a, M & mutex b) {
+        waitfor(f); //ambiguous, keep a pass b or other way around?
+}
 \end{cfacode}
 …
 \begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor( f, b );
+        }
+\end{cfacode}
+This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{b} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{a}). This behavior can be extended to multi-monitor waitfor statment as follows.
+\begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor( f, a, b);
+        }
+\end{cfacode}
+Note that the set of monitors passed to the \code{waitfor} statement must be entirely contained in the set of monitor already acquired in the routine. \code{waitfor} used in any other context is Undefined Behaviour.
+An important behavior to note is that what happens when set of monitors only match partially :
+\begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor(f, a, b);
+        }
+        A a1, a2;
+        B b;
+        void foo() {
+                g(a1, b);
+        }
+        void bar() {
+                f(a2, b);
+        }
+\end{cfacode}
+While the equivalent can happen when using internal scheduling, the fact that conditions are branded on first use means that users have to use two different condition variables. In both cases, partially matching monitor sets will not wake-up the waiting thread. It is also important to note that in the case of external scheduling, as for routine calls, the order of parameters is important; \code{waitfor(f,a,b)} and \code{waitfor(f,b,a)} are to distinct waiting condition.
+% ======================================================================
+% ======================================================================
+\subsection{Implementation Details: External scheduling queues}
+% ======================================================================
+% ======================================================================
+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
+monitor M {};
+void f(M & mutex a);
+void g(M & mutex a, M & mutex b) {
+        waitfor( f, b );
+}
+\end{cfacode}
+This syntax is unambiguous. Both locks are acquired and kept. When routine \code{f} is called, the lock for monitor \code{b} is temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{a}). This behavior can be extended to multi-monitor waitfor statement as follows.
+\begin{cfacode}
+monitor M {};
+void f(M & mutex a, M & mutex b);
+void g(M & mutex a, M & mutex b) {
+        waitfor( f, a, b);
+}
+\end{cfacode}
+Note that the set of monitors passed to the \code{waitfor} statement must be entirely contained in the set of monitors already acquired in the routine. \code{waitfor} used in any other context is Undefined Behaviour.
+An important behavior to note is that what happens when a set of monitors only match partially :
+\begin{cfacode}
+mutex struct A {};
+mutex struct B {};
+void g(A & mutex a, B & mutex b) {
+        waitfor(f, a, b);
+}
+A a1, a2;
+B b;
+void foo() {
+        g(a1, b); //block on accept
+}
+void bar() {
+        f(a2, b); //fufill cooperation
+}
+\end{cfacode}
+While the equivalent can happen when using internal scheduling, the fact that conditions are specific to a set of monitors means that users have to use two different condition variables. In both cases, partially matching monitor sets does not wake-up the waiting thread. It is also important to note that in the case of external scheduling, as for routine calls, the order of parameters is important; \code{waitfor(f,a,b)} and \code{waitfor(f,b,a)} are to distinct waiting condition.
+% ======================================================================
+% ======================================================================
+\subsection{\code{waitfor} semantics}
+% ======================================================================
+% ======================================================================
+Syntactically, the \code{waitfor} statement takes a function identifier and a set of monitors. While the set of monitors can be any list of expression, the function name is more restricted. This is because the compiler validates at compile time the validity of the waitfor statement. It checks that the set of monitor passed in matches the requirements for a function call. Listing \ref{lst:waitfor} shows various usage of the waitfor statement and which are acceptable. The choice of the function type is made ignoring any non-\code{mutex} parameter. One limitation of the current implementation is that it does not handle overloading.
+\begin{figure}
+\begin{cfacode}
+monitor A{};
+monitor B{};
+void f1( A & mutex );
+void f2( A & mutex, B & mutex );
+void f3( A & mutex, int );
+void f4( A & mutex, int );
+void f4( A & mutex, double );
+void foo( A & mutex a1, A & mutex a2, B & mutex b1, B & b2 ) {
+        A * ap = & a1;
+        void (*fp)( A & mutex ) = f1;
+        waitfor(f1, a1);     //Correct : 1 monitor case
+        waitfor(f2, a1, b1); //Correct : 2 monitor case
+        waitfor(f3, a1);     //Correct : non-mutex arguments are ignored
+        waitfor(f1, *ap);    //Correct : expression as argument
+        waitfor(f1, a1, b1); //Incorrect : Too many mutex arguments
+        waitfor(f2, a1);     //Incorrect : Too few mutex arguments
+        waitfor(f2, a1, a2); //Incorrect : Mutex arguments don't match
+        waitfor(f1, 1);      //Incorrect : 1 not a mutex argument
+        waitfor(f4, a1);     //Incorrect : f9 not a function
+        waitfor(*fp, a1 );   //Incorrect : fp not a identifier
+        waitfor(f4, a1);     //Incorrect : f4 ambiguous
+        waitfor(f2, a1, b2); //Undefined Behaviour : b2 may not acquired
+}
+\end{cfacode}
+\caption{Various correct and incorrect uses of the waitfor statement}
+\label{lst:waitfor}
+\end{figure}
+Finally, for added flexibility, \CFA supports constructing complex waitfor mask using the \code{or}, \code{timeout} and \code{else}. Indeed, multiple \code{waitfor} can be chained together using \code{or}; this chain will form a single statement which will baton-pass to any one function that fits one of the function+monitor set which was passed in. To eanble users to tell which was the accepted function, \code{waitfor}s are followed by a statement (including the null statement \code{;}) or a compound statement. When multiple \code{waitfor} are chained together, only the statement corresponding to the accepted function is executed. A \code{waitfor} chain can also be followed by a \code{timeout}, to signify an upper bound on the wait, or an \code{else}, to signify that the call should be non-blocking, that is only check of a matching function already arrived and return immediately otherwise. Any and all of these clauses can be preceded by a \code{when} condition to dynamically construct the mask based on some current state. Listing \ref{lst:waitfor2}, demonstrates several complex masks and some incorrect ones.
+\begin{figure}
+\begin{cfacode}
+monitor A{};
+void f1( A & mutex );
+void f2( A & mutex );
+void foo( A & mutex a, bool b, int t ) {
+        //Correct : blocking case
+        waitfor(f1, a);
+        //Correct : block with statement
+        waitfor(f1, a) {
+                sout | "f1" | endl;
+        }
+        //Correct : block waiting for f1 or f2
+        waitfor(f1, a) {
+                sout | "f1" | endl;
+        } or waitfor(f2, a) {
+                sout | "f2" | endl;
+        }
+        //Correct : non-blocking case
+        waitfor(f1, a); or else;
+        //Correct : non-blocking case
+        waitfor(f1, a) {
+                sout | "blocked" | endl;
+        } or else {
+                sout | "didn't block" | endl;
+        }
+        //Correct : block at most 10 seconds
+        waitfor(f1, a) {
+                sout | "blocked" | endl;
+        } or timeout( 10`s) {
+                sout | "didn't block" | endl;
+        }
+        //Correct : block only if b == true
+        //if b == false, don't even make the call
+        when(b) waitfor(f1, a);
+        //Correct : block only if b == true
+        //if b == false, make non-blocking call
+        waitfor(f1, a); or when(!b) else;
+        //Correct : block only of t > 1
+        waitfor(f1, a); or when(t > 1) timeout(t); or else;
+        //Incorrect : timeout clause is dead code
+        waitfor(f1, a); or timeout(t); or else;
+        //Incorrect : order must be
+        //waitfor [or waitfor... [or timeout] [or else]]
+        timeout(t); or waitfor(f1, a); or else;
+}
+\end{cfacode}
+\caption{Various correct and incorrect uses of the or, else, and timeout clause around a waitfor statement}
+\label{lst:waitfor2}
+\end{figure}

doc/proposals/concurrency/text/intro.tex

-              rb96ec83
+              r6840e7c
 % ======================================================================
 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 thesis provides a minimal concurrency \acrshort{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 concurrency. 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. The high-level approach and its minimal \acrshort{api} are tested in a dialect of C, call \CFA. [Is there value to say that this thesis is also an early definition of the \CFA language and library in regards to concurrency?]
 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 programmer. 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

-              rb96ec83
+              r6840e7c
 \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.
+An 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 limit 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 a context switch is more expensive 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}
+\subsection{Future Work: Machine setup}\label{machine}
+While this was not done in the context of this thesis, 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

-              rb96ec83
+              r6840e7c
 % 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
 …
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \setcounter{secnumdepth}{3}                           % number subsubsections
 \setcounter{tocdepth}{3}                              % subsubsections in table of contents
+\setcounter{secnumdepth}{2}                           % number subsubsections
+\setcounter{tocdepth}{2}                              % subsubsections in table of contents
 % \linenumbers                                          % comment out to turn off line numbering
 \makeindex
 …
 \input{parallelism}
+\chapter{Putting it all together}
+\input{internals}
+\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

rb96ec83	r6840e7c
1		0.~~9.180~~
	1	0.10.212

src/CodeGen/CodeGenerator.cc

-              rb96ec83
+              r6840e7c
         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
                 assertf( ! genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->get_name();
                 if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
                         output << " | sized(" << typeDecl->get_name() << ")";
+                }
                 if ( ! typeDecl->get_assertions().empty() ) {
+                output << typeDecl->genTypeString() << " " << typeDecl->name;
+                if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->sized ) {
+                        output << " | sized(" << typeDecl->name << ")";
+                }
+                if ( ! typeDecl->assertions.empty() ) {
                         output << " | { ";
+                        genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
+                        for ( DeclarationWithType * assert :  typeDecl->assertions ) {
+                                assert->accept( *visitor );
+                                output << "; ";
+                        }
                         output << " }";
+                }
 …
                 output << ";";
+        }
+        void CodeGenerator::postvisit( CatchStmt * stmt ) {
+                assertf( ! genC, "Catch statements should not reach code generation." );
+                output << ((stmt->get_kind() == CatchStmt::Terminate) ?
+                "catch" : "catchResume");
+                output << "( ";
+                stmt->decl->accept( *visitor );
+                output << " ) ";
+                if( stmt->cond ) {
+                        output << "if/when(?) (";
+                        stmt->cond->accept( *visitor );
+                        output << ") ";
+                }
+                stmt->body->accept( *visitor );
+        }
+        void CodeGenerator::postvisit( WaitForStmt * stmt ) {
+                assertf( ! genC, "Waitfor statements should not reach code generation." );
+                bool first = true;
+                for( auto & clause : stmt->clauses ) {
+                        if(first) { output << "or "; first = false; }
+                        if( clause.condition ) {
+                                output << "when(";
+                                stmt->timeout.condition->accept( *visitor );
+                                output << ") ";
+                        }
+                        output << "waitfor(";
+                        clause.target.function->accept( *visitor );
+                        for( Expression * expr : clause.target.arguments ) {
+                                output << ",";
+                                expr->accept( *visitor );
+                        }
+                        output << ") ";
+                        clause.statement->accept( *visitor );
+                }
+                if( stmt->timeout.statement ) {
+                        output << "or ";
+                        if( stmt->timeout.condition ) {
+                                output << "when(";
+                                stmt->timeout.condition->accept( *visitor );
+                                output << ") ";
+                        }
+                        output << "timeout(";
+                        stmt->timeout.time->accept( *visitor );
+                        output << ") ";
+                        stmt->timeout.statement->accept( *visitor );
+                }
+                if( stmt->orelse.statement ) {
+                        output << "or ";
+                        if( stmt->orelse.condition ) {
+                                output << "when(";
+                                stmt->orelse.condition->accept( *visitor );
+                                output << ")";
+                        }
+                        output << "else ";
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
 …
+        }
 } // namespace CodeGen
+unsigned Indenter::tabsize = 2;
 std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {

src/CodeGen/CodeGenerator.h

rb96ec83	r6840e7c
100	100	void postvisit( ReturnStmt * );
101	101	void postvisit( ThrowStmt * );
	102	void postvisit( CatchStmt * );
	103	void postvisit( WaitForStmt * );
102	104	void postvisit( WhileStmt * );
103	105	void postvisit( ForStmt * );

src/CodeGen/FixNames.cc

-              rb96ec83
+              r6840e7c
                 );
                 mainDecl->get_functionType()->get_parameters().push_back(
+                main_type->get_parameters().push_back(
                         new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
                 );
                 mainDecl->get_functionType()->get_parameters().push_back(
+                main_type->get_parameters().push_back(
                         new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
                         new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),

src/CodeGen/GenType.cc

-              rb96ec83
+              r6840e7c
         std::string GenType::handleGeneric( ReferenceToType * refType ) {
                 if ( ! refType->get_parameters().empty() ) {
+                if ( ! refType->parameters.empty() ) {
                         std::ostringstream os;
                         PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "(";
                         cg.pass.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
+                        cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
                         os << ") ";
                         return os.str();

src/Common/Indenter.h

-              rb96ec83
+              r6840e7c
 struct Indenter {
+        Indenter( unsigned int amt = 2 ) : amt( amt ) {}
+        unsigned int amt = 2;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
+        unsigned int indent = 0;
+        static unsigned tabsize;
+        Indenter( unsigned int amt = tabsize, unsigned int indent = 0 ) : amt( amt ), indent( indent ) {}
+        unsigned int amt;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
+        unsigned int indent;
         Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
 …
 };
 inline std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
+inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) {
         return out << std::string(indent.indent, ' ');
+}

src/Common/PassVisitor.h

-              rb96ec83
+              r6840e7c
 #include <stack>
+#include "Common/utility.h"
 #include "SynTree/Mutator.h"
 …
         virtual Attribute * mutate( Attribute * attribute ) override final;
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final;
 private:
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
         template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
+        template< typename TreeType, typename pass_t > friend void maybeAccept_impl( TreeType * tree, PassVisitor< pass_t > & visitor );
+        template< typename TreeType, typename pass_t > friend void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_t > & mutator );
+        template< typename Container, typename pass_t > friend void maybeAccept_impl( Container & container, PassVisitor< pass_t > & visitor );
+        template< typename Container, typename pass_t > friend void maybeMutate_impl( Container & container, PassVisitor< pass_t > & mutator );
         template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
 …
         std::list< Declaration* > *     get_afterDecls () { return declsToAddAfter_impl ( pass, 0); }
+        void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
+        bool       get_visit_children    () { bool_ref * ptr = visit_children_impl(pass, 0); return ptr ? *ptr : true; }
+        bool_ref * get_visit_children_ptr() { return visit_children_impl(pass, 0); }
         void indexerScopeEnter  ()                             { indexer_impl_enterScope  ( pass, 0       ); }

src/Common/PassVisitor.impl.h

-              rb96ec83
+              r6840e7c
 // IWYU pragma: private, include "PassVisitor.h"
+#define VISIT_START( node )                     \
+        __attribute__((unused))                   \
+#define VISIT_START( node )                                     \
+        __attribute__((unused))                                   \
+        ChildrenGuard children_guard( get_visit_children_ptr() ); \
+        __attribute__((unused))                                   \
         guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
+        call_previsit( node );                    \
+        if( visit_children ) {                    \
+        call_previsit( node );                                    \
 #define VISIT_END( node )                       \
-        }                                         \
         call_postvisit( node );                   \
+#define MUTATE_START( node )                    \
+        __attribute__((unused))                   \
+#define MUTATE_START( node )                                    \
+        __attribute__((unused))                                   \
+        ChildrenGuard children_guard( get_visit_children_ptr() ); \
+        __attribute__((unused))                                   \
         guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
+        call_premutate( node );                   \
+        if( visit_children ) {                    \
+        call_premutate( node );                                   \
 #define MUTATE_END( type, node )                \
-        }                                         \
         return call_postmutate< type * >( node ); \
+#define VISIT_BODY( node )        \
+        VISIT_START( node );        \
+        Visitor::visit( node );     \
+        VISIT_END( node );          \
+#define MUTATE_BODY( type, node ) \
+        MUTATE_START( node );       \
+        Mutator::mutate( node );    \
+        MUTATE_END( type, node );   \
+#define VISIT_BODY( node )          \
+        VISIT_START( node );          \
+        if( children_guard ) {        \
+                Visitor::visit( node ); \
+        }                             \
+        VISIT_END( node );            \
+#define MUTATE_BODY( type, node )    \
+        MUTATE_START( node );          \
+        if( children_guard ) {         \
+                Mutator::mutate( node ); \
+        }                              \
+        MUTATE_END( type, node );      \
 …
 template< typename pass_type >
 static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
         DeclList_t* beforeDecls = visitor.get_beforeDecls();
         DeclList_t* afterDecls  = visitor.get_afterDecls();
 …
                 try {
                         // run visitor on declaration
                         maybeAccept( *i, visitor );
+                        maybeAccept_impl( *i, visitor );
                 } catch( SemanticError &e ) {
                         e.set_location( (*i)->location );
 …
 template< typename pass_type >
 static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
         DeclList_t* beforeDecls = mutator.get_beforeDecls();
         DeclList_t* afterDecls  = mutator.get_afterDecls();
 …
                 try {
                         // run mutator on declaration
                         *i = maybeMutate( *i, mutator );
+                        maybeMutate_impl( *i, mutator );
                 } catch( SemanticError &e ) {
                         e.set_location( (*i)->location );
 …
+}
+template< typename Container, typename VisitorType >
+inline void maybeAccept( Container &container, VisitorType &visitor ) {
+template< typename TreeType, typename pass_type >
+inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
+        if ( tree ) {
+                tree->accept( visitor );
+        }
+}
+template< typename Container, typename pass_type >
+inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
         SemanticError errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 …
+}
+template< typename Container, typename MutatorType >
+inline void maybeMutateRef( Container &container, MutatorType &mutator ) {
+template< typename TreeType, typename pass_type >
+inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
+        if ( tree ) {
+                tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) );
+        }
+}
+template< typename Container, typename pass_type >
+inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
         SemanticError errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
                         if ( *i ) {
-///                 *i = (*i)->acceptMutator( mutator );
                                 *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
                                 assert( *i );
 …
 template< typename func_t >
 void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
+        if ( ! get_visit_children() ) return;
         SemanticError errors;
 …
 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
         handleStatementList( statements, [this]( Statement * stmt) {
                 stmt->accept( *this );
+                maybeAccept_impl( stmt, *this );
         });
+}
 …
 void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
         handleStatementList( statements, [this]( Statement *& stmt) {
                 stmt = stmt->acceptMutator( *this );
+                maybeMutate_impl( stmt, *this );
         });
+}
 …
 template< typename func_t >
 Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
+        if ( ! get_visit_children() ) return stmt;
         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
         ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
 …
 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
                 maybeAccept( stmt, *this );
+                maybeAccept_impl( stmt, *this );
                 return stmt;
         });
 …
 Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
+                return maybeMutate( stmt, *this );
+                maybeMutate_impl( stmt, *this );
+                return stmt;
         });
+}
 …
 template< typename func_t >
 Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
+        if ( ! get_visit_children() ) return expr;
         if( !expr ) return nullptr;
 …
+        }
         // should env be cloned (or moved) onto the result of the mutate?
+        // should env be moved onto the result of the mutate?
         return func( expr );
+}
 …
 Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
         return handleExpression(expr, [this]( Expression * expr ) {
                 expr->accept( *this );
+                maybeAccept_impl( expr, *this );
                 return expr;
         });
 …
 Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
         return handleExpression(expr, [this]( Expression * expr ) {
+                return expr->acceptMutator( *this );
+                maybeMutate_impl( expr, *this );
+                return expr;
         });
+}
+template< typename TreeType, typename VisitorType >
+inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
+        auto guard = makeFuncGuard(
+                [&visitor]() { visitor.indexerScopeEnter(); },
+                [&visitor]() { visitor.indexerScopeLeave(); }
+        );
+        maybeAccept_impl( tree, visitor );
+}
+template< typename TreeType, typename MutatorType >
+inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
+        auto guard = makeFuncGuard(
+                [&mutator]() { mutator.indexerScopeEnter(); },
+                [&mutator]() { mutator.indexerScopeLeave(); }
+        );
+        maybeMutate_impl( tree, mutator );
+}
 …
         indexerScopedAccept( node->type         , *this );
         maybeAccept        ( node->init         , *this );
         maybeAccept        ( node->bitfieldWidth, *this );
         maybeAccept        ( node->attributes   , *this );
+        maybeAccept_impl   ( node->init         , *this );
+        maybeAccept_impl   ( node->bitfieldWidth, *this );
+        maybeAccept_impl   ( node->attributes   , *this );
         if ( node->name != "" ) {
 …
         indexerScopedMutate( node->type         , *this );
         maybeMutateRef     ( node->init         , *this );
         maybeMutateRef     ( node->bitfieldWidth, *this );
         maybeMutateRef     ( node->attributes   , *this );
+        maybeMutate_impl   ( node->init         , *this );
+        maybeMutate_impl   ( node->bitfieldWidth, *this );
+        maybeMutate_impl   ( node->attributes   , *this );
         if ( node->name != "" ) {
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->type, *this );
                 maybeAccept( node->statements, *this );
                 maybeAccept( node->attributes, *this );
+                maybeAccept_impl( node->type, *this );
+                maybeAccept_impl( node->statements, *this );
+                maybeAccept_impl( node->attributes, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->type, *this );
                 maybeMutateRef( node->statements, *this );
                 maybeMutateRef( node->attributes, *this );
+                maybeMutate_impl( node->type, *this );
+                maybeMutate_impl( node->statements, *this );
+                maybeMutate_impl( node->attributes, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
         // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeAccept( node->parameters, *this );
         maybeAccept( node->members   , *this );
+        maybeAccept_impl( node->parameters, *this );
+        maybeAccept_impl( node->members   , *this );
         VISIT_END( node );
 …
         // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeMutateRef( node->parameters, *this );
         maybeMutateRef( node->members   , *this );
+        maybeMutate_impl( node->parameters, *this );
+        maybeMutate_impl( node->members   , *this );
         MUTATE_END( Declaration, node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->base      , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->base      , *this );
+        }
 …
         indexerAddType( node );
         maybeAccept( node->assertions, *this );
+        maybeAccept_impl( node->assertions, *this );
         indexerScopedAccept( node->init, *this );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->base      , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->base      , *this );
+        }
 …
         indexerAddType( node );
         maybeMutateRef( node->assertions, *this );
+        maybeMutate_impl( node->assertions, *this );
         indexerScopedMutate( node->init, *this );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->base      , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->base      , *this );
+        }
         indexerAddType( node );
         maybeAccept( node->assertions, *this );
+        maybeAccept_impl( node->assertions, *this );
         VISIT_END( node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef     ( node->parameters, *this );
                 maybeMutateRef( node->base      , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->base      , *this );
+        }
         indexerAddType( node );
         maybeMutateRef( node->assertions, *this );
+        maybeMutate_impl( node->assertions, *this );
         MUTATE_END( Declaration, node );
 …
         VISIT_START( node );
         maybeAccept( node->stmt, *this );
+        maybeAccept_impl( node->stmt, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->stmt, *this );
+        maybeMutate_impl( node->stmt, *this );
         MUTATE_END( AsmDecl, node );
 …
                 // if statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 acceptAll( node->get_initialization(), *this );
                 visitExpression( node->condition );
+                maybeAccept_impl( node->get_initialization(), *this );
+                visitExpression ( node->condition );
                 node->thenPart = visitStatement( node->thenPart );
                 node->elsePart = visitStatement( node->elsePart );
 …
                 // if statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->get_initialization(), *this );
+                maybeMutate_impl( node->get_initialization(), *this );
                 node->condition = mutateExpression( node->condition );
                 node->thenPart  = mutateStatement ( node->thenPart  );
 …
                 // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->initialization, *this );
+                maybeAccept_impl( node->initialization, *this );
                 visitExpression( node->condition );
                 visitExpression( node->increment );
 …
                 // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->initialization, *this );
+                maybeMutate_impl( node->initialization, *this );
                 node->condition = mutateExpression( node->condition );
                 node->increment = mutateExpression( node->increment );
 …
         VISIT_START( node );
         maybeAccept( node->block       , *this );
         maybeAccept( node->handlers    , *this );
         maybeAccept( node->finallyBlock, *this );
+        maybeAccept_impl( node->block       , *this );
+        maybeAccept_impl( node->handlers    , *this );
+        maybeAccept_impl( node->finallyBlock, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->block       , *this );
         maybeMutateRef( node->handlers    , *this );
         maybeMutateRef( node->finallyBlock, *this );
+        maybeMutate_impl( node->block       , *this );
+        maybeMutate_impl( node->handlers    , *this );
+        maybeMutate_impl( node->finallyBlock, *this );
         MUTATE_END( Statement, node );
 …
                 // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->decl, *this );
+                maybeAccept_impl( node->decl, *this );
                 node->cond = visitExpression( node->cond );
                 node->body = visitStatement ( node->body );
 …
                 // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->decl, *this );
+                maybeMutate_impl( node->decl, *this );
                 node->cond = mutateExpression( node->cond );
                 node->body = mutateStatement ( node->body );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->function, *this );
         maybeAccept        ( node->args    , *this );
+        maybeAccept_impl        ( node->function, *this );
+        maybeAccept_impl        ( node->args    , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->function, *this );
         maybeMutateRef     ( node->args    , *this );
+        maybeMutate_impl   ( node->function, *this );
+        maybeMutate_impl   ( node->args    , *this );
         MUTATE_END( Expression, node );
 …
         VISIT_START( node );
         // maybeAccept( node->get_env(), *this );
+        // maybeAccept_impl( node->get_env(), *this );
         indexerScopedAccept( node->result, *this );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg   , *this );
+        maybeAccept_impl        ( node->arg   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept( node->arg, *this );
+        maybeAccept_impl( node->arg, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg   , *this );
+        maybeAccept_impl   ( node->arg   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( node->aggregate, *this );
         maybeAccept        ( node->member   , *this );
+        maybeAccept_impl   ( node->aggregate, *this );
+        maybeAccept_impl   ( node->member   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env      , *this );
         indexerScopedMutate( node->result   , *this );
         maybeMutateRef     ( node->aggregate, *this );
         maybeMutateRef     ( node->member   , *this );
+        maybeMutate_impl   ( node->aggregate, *this );
+        maybeMutate_impl   ( node->member   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( node->aggregate, *this );
+        maybeAccept_impl   ( node->aggregate, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env      , *this );
         indexerScopedMutate( node->result   , *this );
         maybeMutateRef     ( node->aggregate, *this );
+        maybeMutate_impl   ( node->aggregate, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( &node->constant, *this );
+        maybeAccept_impl   ( &node->constant, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
+        node->constant = *maybeMutate( &node->constant, *this );
+        Constant * ptr = &node->constant;
+        maybeMutate_impl( ptr, *this );
+        node->constant = *ptr;
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
+        maybeAccept_impl   ( node->type  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
         maybeAccept        ( node->member, *this );
+        maybeAccept_impl   ( node->type  , *this );
+        maybeAccept_impl   ( node->member, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
         maybeMutateRef     ( node->member, *this );
+        maybeMutate_impl   ( node->type  , *this );
+        maybeMutate_impl   ( node->member, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
+        maybeAccept_impl   ( node->type  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
+        maybeAccept_impl   ( node->arg1  , *this );
+        maybeAccept_impl   ( node->arg2  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
         maybeAccept        ( node->arg3  , *this );
+        maybeAccept_impl        ( node->arg1  , *this );
+        maybeAccept_impl        ( node->arg2  , *this );
+        maybeAccept_impl        ( node->arg3  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
         maybeMutateRef     ( node->arg3  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg3  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
+        maybeAccept_impl   ( node->arg1  , *this );
+        maybeAccept_impl   ( node->arg2  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type, *this );
+        maybeAccept_impl   ( node->type, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result    , *this );
         maybeAccept        ( node->inout     , *this );
         maybeAccept        ( node->constraint, *this );
         maybeAccept        ( node->operand   , *this );
+        maybeAccept_impl   ( node->inout     , *this );
+        maybeAccept_impl   ( node->constraint, *this );
+        maybeAccept_impl   ( node->operand   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env       , *this );
         indexerScopedMutate( node->result    , *this );
         maybeMutateRef     ( node->inout     , *this );
         maybeMutateRef     ( node->constraint, *this );
         maybeMutateRef     ( node->operand   , *this );
+        maybeMutate_impl   ( node->inout     , *this );
+        maybeMutate_impl   ( node->constraint, *this );
+        maybeMutate_impl   ( node->operand   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->callExpr   , *this );
         maybeAccept        ( node->tempDecls  , *this );
         maybeAccept        ( node->returnDecls, *this );
         maybeAccept        ( node->dtors      , *this );
+        maybeAccept_impl   ( node->callExpr   , *this );
+        maybeAccept_impl   ( node->tempDecls  , *this );
+        maybeAccept_impl   ( node->returnDecls, *this );
+        maybeAccept_impl   ( node->dtors      , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env        , *this );
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->callExpr   , *this );
         maybeMutateRef     ( node->tempDecls  , *this );
         maybeMutateRef     ( node->returnDecls, *this );
         maybeMutateRef     ( node->dtors      , *this );
+        maybeMutate_impl   ( node->callExpr   , *this );
+        maybeMutate_impl   ( node->tempDecls  , *this );
+        maybeMutate_impl   ( node->returnDecls, *this );
+        maybeMutate_impl   ( node->dtors      , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->callExpr, *this );
+        maybeAccept_impl   ( node->callExpr, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->callExpr, *this );
+        maybeMutate_impl   ( node->callExpr, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->initializer, *this );
+        maybeAccept_impl   ( node->initializer, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env        , *this );
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->initializer, *this );
+        maybeMutate_impl     ( node->initializer, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->low   , *this );
         maybeAccept        ( node->high  , *this );
+        maybeAccept_impl   ( node->low   , *this );
+        maybeAccept_impl   ( node->high  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->low   , *this );
         maybeMutateRef     ( node->high  , *this );
+        maybeMutate_impl   ( node->low   , *this );
+        maybeMutate_impl   ( node->high  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->exprs , *this );
+        maybeAccept_impl   ( node->exprs , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->exprs , *this );
+        maybeMutate_impl   ( node->exprs , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept          ( node->exprs , *this );
+        maybeAccept_impl   ( node->exprs , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->exprs , *this );
+        maybeMutate_impl   ( node->exprs , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->tuple , *this );
+        maybeAccept_impl   ( node->tuple , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->tuple , *this );
+        maybeMutate_impl   ( node->tuple , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->stmtExpr, *this );
+        maybeAccept_impl   ( node->stmtExpr, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->stmtExpr, *this );
+        maybeMutate_impl   ( node->stmtExpr, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->statements , *this );
         maybeAccept        ( node->returnDecls, *this );
         maybeAccept        ( node->dtors      , *this );
+        maybeAccept_impl   ( node->statements , *this );
+        maybeAccept_impl   ( node->returnDecls, *this );
+        maybeAccept_impl   ( node->dtors      , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->statements , *this );
         maybeMutateRef     ( node->returnDecls, *this );
         maybeMutateRef     ( node->dtors      , *this );
+        maybeMutate_impl   ( node->statements , *this );
+        maybeMutate_impl   ( node->returnDecls, *this );
+        maybeMutate_impl   ( node->dtors      , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->expr  , *this );
+        maybeAccept_impl   ( node->expr  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->expr  , *this );
+        maybeMutate_impl   ( node->expr  , *this );
         MUTATE_END( Expression, node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->forall    , *this );
                 maybeAccept( node->parameters, *this );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->forall    , *this );
                 maybeMutateRef( node->parameters, *this );
+                maybeMutate_impl( node->forall    , *this );
+                maybeMutate_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->forall    , *this );
                 maybeAccept( node->parameters, *this );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->forall    , *this );
                 maybeMutateRef( node->parameters, *this );
+                maybeMutate_impl( node->forall    , *this );
+                maybeMutate_impl( node->parameters, *this );
+        }
 …
         VISIT_START( node );
         maybeAccept( node->forall    , *this );
         maybeAccept( node->parameters, *this );
+        maybeAccept_impl( node->forall    , *this );
+        maybeAccept_impl( node->parameters, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->forall    , *this );
         maybeMutateRef( node->parameters, *this );
+        maybeMutate_impl( node->forall    , *this );
+        maybeMutate_impl( node->parameters, *this );
         MUTATE_END( Type, node );
 …
         VISIT_START( node );
         maybeAccept( node->get_designators(), *this );
+        maybeAccept_impl( node->get_designators(), *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->get_designators(), *this );
+        maybeMutate_impl( node->get_designators(), *this );
         MUTATE_END( Designation, node );
 …
         MUTATE_BODY( Attribute, node );
+}
+template< typename pass_type >
+TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
+        MUTATE_START( node );
+        for ( auto & p : node->typeEnv ) {
+                indexerScopedMutate( p.second, *this );
+        }
+        for ( auto & p : node->varEnv ) {
+                indexerScopedMutate( p.second, *this );
+        }
+        MUTATE_END( TypeSubstitution, node );
+}

src/Common/PassVisitor.proto.h

-              rb96ec83
+              r6840e7c
         ~bool_ref() = default;
         operator bool() { return *m_ref; }
+        operator bool() { return m_ref ? *m_ref : true; }
         bool operator=( bool val ) { return *m_ref = val; }
 private:
+        template<typename pass>
+        friend class PassVisitor;
+        void set( bool & val ) { m_ref = &val; };
+        bool * m_ref;
+        friend class ChildrenGuard;
+        bool * set( bool & val ) {
+                bool * prev = m_ref;
+                m_ref = &val;
+                return prev;
+        }
+        bool * m_ref = nullptr;
 };
+template< typename TreeType, typename VisitorType >
+inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
+        auto guard = makeFuncGuard(
                 [&visitor]() { visitor.indexerScopeEnter(); },
                 [&visitor]() { visitor.indexerScopeLeave(); }
         );
         maybeAccept( tree, visitor );
+}
+template< typename TreeType, typename MutatorType >
 inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
         auto guard = makeFuncGuard(
                 [&mutator]() { mutator.indexerScopeEnter(); },
                 [&mutator]() { mutator.indexerScopeLeave(); }
+        );
         tree = maybeMutate( tree, mutator );
+}
+template< typename TreeType, typename MutatorType >
+inline void maybeMutateRef( TreeType *& tree, MutatorType & mutator ) {
         tree = maybeMutate( tree, mutator );
+}
+class ChildrenGuard {
+public:
+        ChildrenGuard( bool_ref * ref )
+                : m_val ( true )
+                , m_prev( ref ? ref->set( m_val ) : nullptr )
+                , m_ref ( ref )
+        {}
+        ~ChildrenGuard() {
+                if( m_ref ) {
+                        m_ref->set( *m_prev );
+                }
+        }
+        operator bool() { return m_val; }
+private:
+        bool       m_val;
+        bool     * m_prev;
+        bool_ref * m_ref;
+};
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

src/Common/utility.h

-              rb96ec83
+              r6840e7c
 #include <cassert>
+#include "Common/Indenter.h"
 template< typename T >
 static inline T * maybeClone( const T *orig ) {
 …
 template< typename Container >
 void printAll( const Container &container, std::ostream &os, int indent = 0 ) {
+void printAll( const Container &container, std::ostream &os, Indenter indent = {} ) {
         for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
                 if ( *i ) {
                         os << std::string( indent,  ' ' );
                         (*i)->print( os, indent + 2 );
+                        os << indent;
+                        (*i)->print( os, indent );
                         // need an endl after each element because it's not easy to know when each individual item should end
                         os << std::endl;
 …
 template< typename T1, typename T2 >
 struct group_iterate_t {
+private:
+        std::tuple<T1, T2> args;
+public:
         group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
                 assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
         };
+        typedef std::tuple<decltype(*std::get<0>(args).begin()), decltype(*std::get<1>(args).begin())> value_type;
+        typedef decltype(std::get<0>(args).begin()) T1Iter;
+        typedef decltype(std::get<1>(args).begin()) T2Iter;
         struct iterator {
-                typedef typename std::remove_reference<T1>::type T1val;
-                typedef typename std::remove_reference<T2>::type T2val;
-                typedef std::tuple<typename T1val::value_type &, typename T2val::value_type &> value_type;
-                typedef typename T1val::iterator T1Iter;
-                typedef typename T2val::iterator T2Iter;
                 typedef std::tuple<T1Iter, T2Iter> IterTuple;
                 IterTuple it;
 …
                 value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); }
         };
         iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
         iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
-private:
-        std::tuple<T1, T2> args;
 };

src/Concurrency/Keywords.cc

-              rb96ec83
+              r6840e7c
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
                 void validate( DeclarationWithType * );
+                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
                 void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
 …
                 StructDecl* monitor_decl = nullptr;
                 StructDecl* guard_decl = nullptr;
+                StructDecl* dtor_guard_decl = nullptr;
                 static std::unique_ptr< Type > generic_func;
 …
                 void postvisit( FunctionDecl * decl );
+                void previsit ( StructDecl   * decl );
                 void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
 …
                         acceptAll( translationUnit, impl );
+                }
+          private :
+                bool thread_ctor_seen = false;
+                StructDecl * thread_decl = nullptr;
         };
 …
                 if( mutexArgs.empty() ) return;
+                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl );
+                bool isDtor = CodeGen::isDestructor( decl->name );
+                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl );
                 for(auto arg : mutexArgs) {
                         validate( arg );
 …
                 if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
                 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                addStatments( decl, body, mutexArgs );
+                if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( isDtor ) {
+                        addDtorStatments( decl, body, mutexArgs );
+                }
+                else {
+                        addStatments( decl, body, mutexArgs );
+                }
+        }
 …
                         assert( !guard_decl );
                         guard_decl = decl;
+                }
+                else if( decl->name == "monitor_dtor_guard_t" ) {
+                        assert( !dtor_guard_decl );
+                        dtor_guard_decl = decl;
+                }
+        }
 …
                 //Make sure that typed isn't mutex
                 if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+        }
+        void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                Type * arg_type = args.front()->get_type()->clone();
+                arg_type->set_mutex( false );
+                ObjectDecl * monitors = new ObjectDecl(
+                        "__monitor",
+                        noStorage,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new PointerType(
+                                noQualifiers,
+                                new StructInstType(
+                                        noQualifiers,
+                                        monitor_decl
+                                )
+                        ),
+                        new SingleInit( new UntypedExpr(
+                                new NameExpr( "get_monitor" ),
+                                {  new CastExpr( new VariableExpr( args.front() ), arg_type ) }
+                        ))
+                );
+                assert(generic_func);
+                //in reverse order :
+                // monitor_guard_t __guard = { __monitors, #, func };
+                body->push_front(
+                        new DeclStmt( noLabels, new ObjectDecl(
+                                "__guard",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        dtor_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+                body->push_front( new DeclStmt( noLabels, monitors) );
+        }
 …
         // General entry routine
         //=============================================================================================
+        void ThreadStarter::previsit( StructDecl * decl ) {
+                if( decl->name == "thread_desc" && decl->body ) {
+                        assert( !thread_decl );
+                        thread_decl = decl;
+                }
+        }
         void ThreadStarter::postvisit(FunctionDecl * decl) {
                 if( ! CodeGen::isConstructor(decl->name) ) return;
+                Type * typeof_this = InitTweak::getTypeofThis(decl->type);
+                StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this );
+                if( ctored_type && ctored_type->baseStruct == thread_decl ) {
+                        thread_ctor_seen = true;
+                }
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
                 auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
                 if( type && type->get_baseStruct()->is_thread() ) {
+                        if( !thread_decl || !thread_ctor_seen ) {
+                                throw SemanticError("thread keyword requires threads to be in scope, add #include <thread>");
+                        }
                         addStartStatement( decl, param );
+                }

src/Concurrency/Waitfor.cc

-              rb96ec83
+              r6840e7c
                 Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
                         std::unique_ptr< Expression > expr( makeOpAssign(
+                        Expression * expr = makeOpAssign(
                                 makeOpMember(
                                         makeOpIndex(
 …
                                 ),
                                 value
+                        ) );
+                        return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
+                        );
+                        ResolvExpr::findVoidExpression( expr, indexer );
+                        return new ExprStmt( noLabels, expr );
+                }
 …
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
                 UntypedExpr * set = new UntypedExpr(
+                Expression * set = new UntypedExpr(
                         new NameExpr( "__builtin_memset" ),
+                        {
 …
                 );
+                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
+                delete set;
+                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
+                ResolvExpr::findVoidExpression( set, indexer );
+                stmt->push_back( new ExprStmt( noLabels, set ) );
                 return acceptables;
 …
         Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
                 Expression * untyped = new UntypedExpr(
+                Expression * expr = new UntypedExpr(
                         new NameExpr( "?=?" ),
+                        {
 …
                 );
+                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
+                delete untyped;
+                ResolvExpr::findVoidExpression( expr, indexer );
                 return new ExprStmt( noLabels, expr );
 …
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
                                         Expression * untyped = new CastExpr(
+                                        Expression * init = new CastExpr(
                                                 new UntypedExpr(
                                                         new NameExpr( "get_monitor" ),
 …
                                         );
+                                        Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
+                                        delete untyped;
+                                        ResolvExpr::findSingleExpression( init, indexer );
                                         return new SingleInit( init );
                                 })

src/GenPoly/Box.cc

-              rb96ec83
+              r6840e7c
                         // add size/align for generic types to parameter list
                         if ( ! appExpr->get_function()->has_result() ) return;
+                        if ( ! appExpr->get_function()->result ) return;
                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
                         assert( funcType );
 …
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
+                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
+                        if ( isPolyType( param, exprTyVars ) ) {
+                                Type * newType = arg->get_result()->clone();
+                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
+                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
+                        if ( arg->result->get_lvalue() ) {
+                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                //              return;
+                                //      }
+                                // }
+                                arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                        arg = new CastExpr( arg, param->clone() );
+                                }
+                        } else {
+                                // use type computed in unification to declare boxed variables
+                                Type * newType = param->clone();
                                 if ( env ) env->apply( newType );
+                                std::unique_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
+                                        // if the argument's type is polymorphic, we don't need to box again!
+                                        return;
+                                } else if ( arg->get_result()->get_lvalue() ) {
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                        //              return;
+                                        //      }
+                                        // }
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                                // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                                arg = new CastExpr( arg, param->clone() );
+                                        }
+                                } else {
+                                        // use type computed in unification to declare boxed variables
+                                        Type * newType = param->clone();
+                                        if ( env ) env->apply( newType );
+                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
+                                        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 );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+                                        arg = new AddressExpr( new VariableExpr( newObj ) );
+                                } // if
+                                ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
+                                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 );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+                                arg = new AddressExpr( new VariableExpr( newObj ) );
                         } // if
+                }
 …
                                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                                         if ( varExpr->get_var()->get_name() == "?[?]" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "*?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
 …
                 void Pass1::premutate( AddressExpr * ) { visit_children = false; }
                 Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
                                 if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
                                         if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                                 if ( name->get_name() == "*?" ) {
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
                                                                 assert( appExpr->get_function()->has_result() );
+                                                                assert( appExpr->get_function()->result );
                                                                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
                                                                 assert( function );

src/GenPoly/FindFunction.cc

-              rb96ec83
+              r6840e7c
 #include <utility>                      // for pair
+#include "Common/PassVisitor.h"         // for PassVisitor
 #include "Common/SemanticError.h"       // for SemanticError
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 …
 namespace GenPoly {
         class FindFunction : public Mutator {
+        class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
           public:
                 FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
+                virtual Type *mutate( FunctionType *functionType );
+                virtual Type *mutate( PointerType *pointerType );
+                void premutate( FunctionType * functionType );
+                Type * postmutate( FunctionType * functionType );
+                void premutate( PointerType * pointerType );
           private:
                 void handleForall( const Type::ForallList &forall );
 …
         void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 FindFunction finder( functions, tyVars, false, predicate );
+                PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
                 type->acceptMutator( finder );
+        }
         void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 FindFunction finder( functions, tyVars, true, predicate );
+                PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
                 type = type->acceptMutator( finder );
+        }
 …
         void FindFunction::handleForall( const Type::ForallList &forall ) {
                 for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
+                for ( const Declaration * td : forall ) {
+                        TyVarMap::iterator var = tyVars.find( td->name );
                         if ( var != tyVars.end() ) {
                                 tyVars.erase( var->first );
 …
+        }
+        Type * FindFunction::mutate( FunctionType *functionType ) {
+                tyVars.beginScope();
+        void FindFunction::premutate( FunctionType * functionType ) {
+                visit_children = false;
+                GuardScope( tyVars );
                 handleForall( functionType->get_forall() );
+                mutateAll( functionType->get_returnVals(), *this );
+                mutateAll( functionType->get_returnVals(), *visitor );
+        }
+        Type * FindFunction::postmutate( FunctionType * functionType ) {
                 Type *ret = functionType;
                 if ( predicate( functionType, tyVars ) ) {
 …
                         } // if
                 } // if
-                tyVars.endScope();
                 return ret;
+        }
         Type * FindFunction::mutate( PointerType *pointerType ) {
                 tyVars.beginScope();
+        void FindFunction::premutate( PointerType * pointerType ) {
+                GuardScope( tyVars );
                 handleForall( pointerType->get_forall() );
-                Type *ret = Mutator::mutate( pointerType );
-                tyVars.endScope();
-                return ret;
+        }
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

-              rb96ec83
+              r6840e7c
+        }
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                Type * newType = arg->clone();
+                if ( env ) env->apply( newType );
+                std::unique_ptr<Type> manager( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) {
+                FunctionType * function = getFunctionType( appExpr->function->result );
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
+                TyVarMap exprTyVars( TypeDecl::Data{} );
+                makeTyVarMap( function, exprTyVars );
+                return needsBoxing( param, arg, exprTyVars, env );
+        }
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 // xxx - should this actually be insert?

src/GenPoly/GenPoly.h

-              rb96ec83
+              r6840e7c
         bool typesPolyCompatible( Type *aty, Type *bty );
+        /// true if arg requires boxing given exprTyVars
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env );
+        /// true if arg requires boxing in the call to appExpr
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env );
         /// Adds the type variable `tyVar` to `tyVarMap`
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );

src/GenPoly/Specialize.cc

rb96ec83	r6840e7c
147	147
148	148	Expression * Specialize::doSpecialization( Type formalType, Expression actual, InferredParams *inferParams ) {
149		assertf( actual->~~has_result()~~, "attempting to specialize an untyped expression" );
	149	assertf( actual->result, "attempting to specialize an untyped expression" );
150	150	if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
151	151	if ( FunctionType *funType = getFunctionType( formalType ) ) {

src/GenPoly/module.mk

rb96ec83	r6840e7c
20	20	GenPoly/Lvalue.cc \
21	21	GenPoly/Specialize.cc \
22		~~GenPoly/CopyParams.cc \~~
23	22	GenPoly/FindFunction.cc \
24	23	GenPoly/InstantiateGeneric.cc

src/InitTweak/FixInit.cc

-              rb96ec83
+              r6840e7c
                         /// true if type does not need to be copy constructed to ensure correctness
                         bool skipCopyConstruct( Type * type );
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 …
                 GenStructMemberCalls::generate( translationUnit );
                 // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
                 // hack in the way untyped assignments are generated, where the first argument cannot have
 …
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
                                         *i = maybeMutate( *i, fixer );
+                                        maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
 …
                 Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
-                        assert( appExpr );
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
                                 if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
+                                if ( function->var->linkage.is_builtin ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;
 …
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         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() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->parameters.size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->parameters.front()->get_type() );
+                                                Type * t2 = ftype->parameters.back()->get_type();
                                                 assert( t1 );
 …
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+                        Expression * untyped = exprStmt->get_expr();
+                        Expression * resolved = exprStmt->expr;
+                        exprStmt->expr = nullptr; // take ownership of expr
                         // resolve copy constructor
                         // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
+                        ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
 …
                                 resolved->set_env( nullptr );
                         } // if
                         delete stmt;
                         return resolved;
+                }
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ) {
                         static UniqueName tempNamer("_tmp_cp");
                         assert( env );
                         CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
                         assert( arg->has_result() );
                         Type * result = arg->get_result();
+                        assert( arg->result );
+                        Type * result = arg->result;
                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
                         result = result->clone();
                         env->apply( result );
+                        env->applyFree( result );
                         ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
 …
                                 // if the chosen constructor is intrinsic, the copy is unnecessary, so
                                 // don't create the temporary and don't call the copy constructor
+                                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+                                assert( function );
+                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
+                                VariableExpr * function = strict_dynamic_cast< VariableExpr * >( appExpr->function );
+                                if ( function->var->linkage == LinkageSpec::Intrinsic ) {
+                                        // arguments that need to be boxed need a temporary regardless of whether the copy constructor is intrinsic,
+                                        // so that the object isn't changed inside of the polymorphic function
+                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
+                                }
+                        }
 …
                         // replace argument to function call with temporary
                         arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
                         impCpCtorExpr->get_tempDecls().push_back( tmp );
                         impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                        impCpCtorExpr->tempDecls.push_back( tmp );
+                        impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
+                }
 …
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
                         // take each argument and attempt to copy construct it.
+                        for ( Expression * & arg : appExpr->get_args() ) {
+                                copyConstructArg( arg, impCpCtorExpr );
+                        FunctionType * ftype = GenPoly::getFunctionType( appExpr->function->result );
+                        assert( ftype );
+                        auto & params = ftype->parameters;
+                        auto iter = params.begin();
+                        for ( Expression * & arg : appExpr->args ) {
+                                Type * formal = nullptr;
+                                if ( iter != params.end() ) {
+                                        DeclarationWithType * param = *iter++;
+                                        formal = param->get_type();
+                                }
+                                copyConstructArg( arg, impCpCtorExpr, formal );
                         } // for
 …
                         // initialized with the return value and is destructed later
                         // xxx - handle named return values?
                         Type * result = appExpr->get_result();
+                        Type * result = appExpr->result;
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
 …
                                 env->apply( result );
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
+                                ret->type->set_const( false );
+                                impCpCtorExpr->returnDecls.push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
 …
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
+                                retExpr->set_env( callExpr->get_env() );
+                                callExpr->set_env( nullptr );
+                                std::swap( retExpr->env, callExpr->env );
                                 return retExpr;
                         } else {
 …
                                                 if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
+                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        Expression * ctorArg = ctorCall->args.back();
+                                                        std::swap( ctorArg->env, ctorCall->env );
+                                                        objDecl->init = new SingleInit( ctorArg );
                                                         ctorCall->args.pop_back();
                                                 } else {
 …
                         GuardValue( labelVars );
                         labelVars.clear();
+                        // LabelFinder does not recurse into FunctionDecl, so need to visit
+                        // its children manually.
                         maybeAccept( funcDecl->type, finder );
                         maybeAccept( funcDecl->statements, finder );
 …
+                }
                 DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
+                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
                         // add object to the indexer assumes that there will be no name collisions
                         // in generated code. If this changes, add mutate methods for entities with
 …
+                }
+                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
+                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
+                }
 …
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
                         assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
                         // 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.
 …
                         // resolve assignment and dispose of new env
+                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
+                        delete resolvedAssign->env;
+                        resolvedAssign->env = nullptr;
+                        delete assign;
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
                         // for constructor expr:
 …
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
                         CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/InitTweak/GenInit.cc

-              rb96ec83
+              r6840e7c
                 // should not have a ConstructorInit generated.
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                GenPoly::ScopedSet< std::string > managedTypes;
+                ManagedTypes managedTypes;
                 bool inFunction = false;
         };
 …
                 // 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 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->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() );
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
+                                // return statement has already been mutated - don't need to do it again
+                                if ( varExpr->var == retVal ) return;
+                        }
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
                         // return the retVal object
                         returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->expr = new VariableExpr( returnVals.front() );
                 } // if
+        }
 …
+        }
         bool CtorDtor::isManaged( Type * type ) const {
+        bool ManagedTypes::isManaged( Type * type ) const {
                 // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
 …
+        }
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
 …
+        }
         void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
 …
+                }
+        }
+        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes::endScope() { managedTypes.endScope(); }
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
 …
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
+                managedTypes.handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
                 if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
 …
                 inFunction = true;
                 handleDWT( functionDecl );
+                managedTypes.handleDWT( functionDecl );
                 GuardScope( managedTypes );
 …
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 handleDWT( assertion );
+                                managedTypes.handleDWT( assertion );
+                        }
+                }
 …
                 visit_children = false; // do not try to construct and destruct aggregate members
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+                managedTypes.handleStruct( aggregateDecl );
+        }

src/InitTweak/GenInit.h

-              rb96ec83
+              r6840e7c
 #pragma once
 #include <list>               // for list
 #include <string>             // for string
+#include <list>                // for list
+#include <string>              // for string
+#include "SynTree/SynTree.h"  // for Visitor Nodes
+#include "SynTree/SynTree.h"   // for Visitor Nodes
+#include "GenPoly/ScopedSet.h" // for ScopedSet
 namespace InitTweak {
 …
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
+        class ManagedTypes {
+        public:
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed
+                void beginScope();
+                void endScope();
+        private:
+                GenPoly::ScopedSet< std::string > managedTypes;
+        };
 } // namespace

src/InitTweak/InitTweak.cc

-              rb96ec83
+              r6840e7c
                 deleteAll( indices );
                 indices.clear();
+        }
+        bool InitExpander::addReference() {
+                bool added = false;
+                for ( Expression *& expr : cur ) {
+                        expr = new AddressExpr( expr );
+                        added = true;
+                }
+                return added;
+        }
 …
+        }
         Type * getThisType( FunctionType * ftype ) {
                 assertf( ftype, "getThisType: nullptr ftype" );
                 ObjectDecl * thisParam = getThisParam( ftype );
+        Type * getTypeofThis( FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                ObjectDecl * thisParam = getParamThis( ftype );
                 ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
                 return refType->base;
+        }
         ObjectDecl * getThisParam( FunctionType * ftype ) {
                 assertf( ftype, "getThisParam: nullptr ftype" );
+        ObjectDecl * getParamThis( FunctionType * ftype ) {
+                assertf( ftype, "getParamThis: nullptr ftype" );
                 auto & params = ftype->parameters;
                 assertf( ! params.empty(), "getThisParam: ftype with 0 parameters: %s", toString( ftype ).c_str() );
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() );
                 return strict_dynamic_cast< ObjectDecl * >( params.front() );
+        }
 …
                         assert( expr );
                         if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
                                 return varExpr->get_var();
+                                return varExpr->var;
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
                                 return memberExpr->get_member();
+                                return memberExpr->member;
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 return getCalledFunction( castExpr->get_arg() );
+                                return getCalledFunction( castExpr->arg );
                         } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 return handleDerefCalledFunction( untypedExpr );
 …
                                 return handleDerefCalledFunction( appExpr );
                         } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                                return getCalledFunction( addrExpr->get_arg() );
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
+                        }
                         return nullptr;
 …
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
                 FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
                 if ( ! function ) return 0;
                 if ( function->get_name() != fname ) return 0;
                 FunctionType * ftype = function->get_functionType();
                 if ( ftype->get_parameters().size() != 2 ) return 0;
+                if ( ! function ) return nullptr;
+                if ( function->name != fname ) return nullptr;
+                FunctionType * ftype = function->type;
+                if ( ftype->parameters.size() != 2 ) return nullptr;
                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                 Type * t2 = ftype->get_parameters().back()->get_type();
+                Type * t2 = ftype->parameters.back()->get_type();
                 assert( t1 );
 …
+        }
         FunctionDecl * isDefaultConstructor( Declaration * decl ) {
                 if ( isConstructor( decl->get_name() ) ) {
+                if ( isConstructor( decl->name ) ) {
                         if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
                                 if ( func->get_functionType()->get_parameters().size() == 1 ) {
+                                if ( func->type->parameters.size() == 1 ) {
                                         return func;
+                                }

src/InitTweak/InitTweak.h

-              rb96ec83
+              r6840e7c
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
         Type * getThisType( FunctionType * ftype );
+        Type * getTypeofThis( FunctionType * ftype );
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getThisParam( FunctionType * ftype );
+        ObjectDecl * getParamThis( FunctionType * ftype );
         /// transform Initializer into an argument list that can be passed to a call expression
 …
                 void addArrayIndex( Expression * index, Expression * dimension );
                 void clearArrayIndices();
+                bool addReference();
                 class ExpanderImpl;

src/MakeLibCfa.cc

-              rb96ec83
+              r6840e7c
                         newDecls.push_back( funcDecl );
+                        Statement * stmt = nullptr;
                         switch ( opInfo.type ) {
                           case CodeGen::OT_INDEX:
 …
                           case CodeGen::OT_POSTFIXASSIGN:
                           case CodeGen::OT_INFIXASSIGN:
+                                        // return the recursive call
+                                        stmt = new ReturnStmt( noLabels, newExpr );
+                                        break;
                           case CodeGen::OT_CTOR:
                           case CodeGen::OT_DTOR:
                                 // return the recursive call
                                         funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                                        // execute the recursive call
+                                        stmt = new ExprStmt( noLabels, newExpr );
                                         break;
                           case CodeGen::OT_CONSTANT:
 …
                                 assert( false );
                         } // switch
+                        funcDecl->get_statements()->push_back( stmt );
+                }
         } // namespace

src/Makefile.in

-              rb96ec83
+              r6840e7c
         GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
 …
         ControlStruct/ExceptTranslate.cc GenPoly/Box.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 \
+        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
+        Parser/ParseNode.cc Parser/DeclarationNode.cc \
+        Parser/ExpressionNode.cc Parser/StatementNode.cc \
+        Parser/InitializerNode.cc Parser/TypeData.cc \
+        Parser/LinkageSpec.cc Parser/parserutility.cc \
+        ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
+        ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
+        ResolvExpr/CommonType.cc ResolvExpr/ConversionCost.cc \
+        ResolvExpr/CastCost.cc ResolvExpr/PtrsCastable.cc \
+        ResolvExpr/AdjustExprType.cc ResolvExpr/AlternativePrinter.cc \
+        ResolvExpr/Resolver.cc ResolvExpr/ResolveTypeof.cc \
+        ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
+        ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
+        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
+        GenPoly/Specialize.cc GenPoly/FindFunction.cc \
+        GenPoly/InstantiateGeneric.cc InitTweak/GenInit.cc \
+        InitTweak/FixInit.cc InitTweak/FixGlobalInit.cc \
+        InitTweak/InitTweak.cc Parser/parser.yy Parser/lex.ll \
+        Parser/TypedefTable.cc Parser/ParseNode.cc \
+        Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
+        Parser/StatementNode.cc Parser/InitializerNode.cc \
+        Parser/TypeData.cc Parser/LinkageSpec.cc \
+        Parser/parserutility.cc ResolvExpr/AlternativeFinder.cc \
+        ResolvExpr/Alternative.cc ResolvExpr/Unify.cc \
+        ResolvExpr/PtrsAssignable.cc ResolvExpr/CommonType.cc \
+        ResolvExpr/ConversionCost.cc ResolvExpr/CastCost.cc \
+        ResolvExpr/PtrsCastable.cc ResolvExpr/AdjustExprType.cc \
+        ResolvExpr/AlternativePrinter.cc ResolvExpr/Resolver.cc \
+        ResolvExpr/ResolveTypeof.cc ResolvExpr/RenameVars.cc \
+        ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
+        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
+        ResolvExpr/CurrentObject.cc SymTab/Indexer.cc \
+        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
+        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
+        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
+        SynTree/BasicType.cc SynTree/PointerType.cc \
+        SynTree/ArrayType.cc SynTree/ReferenceType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
 …
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
 …
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
 @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-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.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-Specialize.obj `if test -f 'GenPoly/Specialize.cc'; then $(CYGPATH_W) 'GenPoly/Specialize.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/Specialize.cc'; fi`
-GenPoly/driver_cfa_cpp-CopyParams.o: GenPoly/CopyParams.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-CopyParams.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.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-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc
-GenPoly/driver_cfa_cpp-CopyParams.obj: GenPoly/CopyParams.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-CopyParams.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.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-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi`
 GenPoly/driver_cfa_cpp-FindFunction.o: GenPoly/FindFunction.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-FindFunction.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Tpo -c -o GenPoly/driver_cfa_cpp-FindFunction.o `test -f 'GenPoly/FindFunction.cc' || echo '$(srcdir)/'`GenPoly/FindFunction.cc

src/Parser/DeclarationNode.cc

-              rb96ec83
+              r6840e7c
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug 10 17:02:00 2017
 // Update Count     : 1021
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Sep 23 18:16:48 2017
+// Update Count     : 1024
 //
 …
 using namespace std;
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
+// These must harmonize with the corresponding DeclarationNode enumerations.
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
 const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };

src/Parser/ExpressionNode.cc

-              rb96ec83
+              r6840e7c
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:09:34 2017
 // Update Count     : 690
+// Last Modified On : Wed Sep 27 22:51:55 2017
+// Update Count     : 781
 //
 …
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
+static const char * lnthsInt[2][6] = {
+        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
+        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
+}; // lnthsInt
+static inline void checkLNInt( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 4;                                                                                       // assume largest size
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '8' ) {                                                       // 8
+                lnth = 0;
+        } else if ( str[posn] == '1' ) {
+                posn += 1;
+                if ( str[posn] == '6' ) {                                               // 16
+                        lnth = 1;
+                } else {                                                                                // 128
+                        posn += 1;
+                        lnth = 5;
+                } // if
+        } else {
+                if ( str[posn] == '3' ) {                                               // 32
+                        lnth = 2;
+                } else if ( str[posn] == '6' ) {                                // 64
+                        lnth = 3;
+                } else {
+                        assertf( false, "internal error, bad integral length %s", str.c_str() );
+                } // if
+                posn += 1;
+        } // if
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNInt
 static void sepNumeric( string & str, string & units ) {
         string::size_type posn = str.find_first_of( "`" );
 …
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][5] = {
+        static const BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh)
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
         };
         string units;                                                                           // units
+        string units;
         sepNumeric( str, units );                                                       // separate constant from units
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
+        int lnth = -1;                                                                          // literal length
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
 …
                         } // if
                         str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
+                } else {                                                                                // suffix "ln" ?
+                        checkLNInt( str, lnth, size );
                 } // if
         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
 …
                 str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
         } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
                 size = 5;
+                lnth = 4;
                 str.erase( last, 1 );                                                   // remove 'z'
+        } // if
+        } else {                                                                                        // suffix "ln" ?
+                checkLNInt( str, lnth, size );
+        } // if
+        assert( 0 <= size && size < 6 );
+        // Constant type is correct for overload resolving.
         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
         if ( Unsigned && size < 2 ) {                                           // less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
+        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
+                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+        } else if ( size == 5 ) {                                                       // explicit cast to size_t
+                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
+        } else if ( lnth != -1 ) {                                                      // explicit length ?
+                if ( lnth == 5 ) {                                                              // int128 ?
+                        size = 5;
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                } else {
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
+                } // if
         } // if
   CLEANUP:
 …
         return ret;
 } // build_constantInteger
+static inline void checkLNFloat( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 2;                                                                                       // assume largest size
+        lnth = 0;
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '3' ) {                                                       // 32
+                size = 0;
+        } else if ( str[posn] == '6' ) {                                        // 64
+                size = 1;
+        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
+                size = 2;
+                if ( str[posn] == '1' ) posn += 1;
+        } else {
+                assertf( false, "internal error, bad floating point length %s", str.c_str() );
+        } // if
+        posn += 1;
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNFloat
 Expression * build_constantFloat( string & str ) {
 …
         };
         string units;                                                                           // units
+        string units;
         sepNumeric( str, units );                                                       // separate constant from units
         bool complx = false;                                                            // real, complex
+        int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
+        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
+        int lnth = -1;                                                                          // literal length
         // floating-point constant has minimum of 2 characters: 1. or .1
         size_t last = str.length() - 1;
 …
         } else if ( checkL( str[last] ) ) {                                     // long double ?
                 size = 2;
+        } else {
+                size = 1;                                                                               // double (default)
+                checkLNFloat( str, lnth, size );
         } // if
         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
 …
         } // if
+        assert( 0 <= size && size < 3 );
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
+        if ( lnth != -1 ) {                                                                     // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
+        } // if
         if ( units.length() != 0 ) {
                 ret = new UntypedExpr( new NameExpr( units ), { ret } );
 …
 NameExpr * build_varref( const string * name ) {
         NameExpr * expr = new NameExpr( *name, nullptr );
+        NameExpr * expr = new NameExpr( *name );
         delete name;
         return expr;
 …
         list< Expression * > args;
         buildMoveList( expr_node, args );
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
 } // build_func

src/Parser/ParseNode.h

-              rb96ec83
+              r6840e7c
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:09:39 2017
 // Update Count     : 815
+// Last Modified On : Sat Sep 23 18:11:22 2017
+// Update Count     : 821
 //
 …
 #define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
-extern char * yyfilename;
-extern int yylineno;
 extern YYLTYPE yylloc;
 …
 class DeclarationNode : public ParseNode {
   public:
+        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
+        // These enumerations must harmonize with their names.
+        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
+        static const char * basicTypeNames[];
         enum ComplexType { Complex, Imaginary, NoComplexType };
+        static const char * complexTypeNames[];
         enum Signedness { Signed, Unsigned, NoSignedness };
+        static const char * signednessNames[];
         enum Length { Short, Long, LongLong, NoLength };
+        static const char * lengthNames[];
         enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
+        static const char * aggregateNames[];
         enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
+        static const char * typeClassNames[];
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };
-        static const char * basicTypeNames[];
-        static const char * complexTypeNames[];
-        static const char * signednessNames[];
-        static const char * lengthNames[];
-        static const char * aggregateNames[];
-        static const char * typeClassNames[];
         static const char * builtinTypeNames[];

src/Parser/TypeData.cc

-              rb96ec83
+              r6840e7c
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Sep  1 23:13:38 2017
 // Update Count     : 569
+// Last Modified On : Mon Sep 25 18:33:41 2017
+// Update Count     : 587
 //
 …
 } // TypeData::TypeData
 TypeData::~TypeData() {
         delete base;
 …
         } // switch
 } // TypeData::~TypeData
 TypeData * TypeData::clone() const {
 …
 } // TypeData::clone
 void TypeData::print( ostream &os, int indent ) const {
         for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
 …
         } // switch
 } // TypeData::print
 template< typename ForallList >
 …
                 } // if
         } // for
+}
+} // buildForall
 Type * typebuild( const TypeData * td ) {
 …
 } // typebuild
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
         TypeData * ret = nullptr;
 …
 } // typeextractAggregate
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
+static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
+        throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+} // genTSError
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
 …
         switch ( td->basictype ) {
           case DeclarationNode::Void:
+                if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) {
+                        throw SemanticError( "invalid type specifier \"void\" in type: ", td );
+                } // if
+                if ( td->signedness != DeclarationNode::NoSignedness ) {
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
 …
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 …
                 if ( td->length != DeclarationNode::NoLength ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 …
                 break;
+          case DeclarationNode::Int128:
+                ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
+                break;
           case DeclarationNode::Float:
+          case DeclarationNode::Float80:
+          case DeclarationNode::Float128:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
 …
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
                         throw SemanticError( "invalid type specifier \"long\" in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Long ) {
 …
                 goto Integral;
           default:
                 assert(false);
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
 …
         return bt;
 } // buildBasicType
 PointerType * buildPointer( const TypeData * td ) {
 …
         return pt;
 } // buildPointer
 ArrayType * buildArray( const TypeData * td ) {
 …
 } // buildArray
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
 …
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
 …
         return at;
 } // buildAggregate
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 …
 } // buildAggInst
 ReferenceToType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
 …
 } // buildAggInst
 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
 …
 } // buildSymbolic
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
 …
 } // buildEnum
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
 …
         return ret;
 } // buildSymbolicInst
 TupleType * buildTuple( const TypeData * td ) {
 …
 } // buildTuple
 TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof );
 …
         return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
 } // buildTypeof
 Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
 …
         return nullptr;
 } // buildDecl
 FunctionType * buildFunction( const TypeData * td ) {
 …
         return ft;
 } // buildFunction
 // Transform KR routine declarations into C99 routine declarations:

src/Parser/lex.ll

-              rb96ec83
+              r6840e7c
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sun Sep 10 22:29:15 2017
  * Update Count     : 620
+ * Last Modified On : Sat Sep 23 17:29:28 2017
+ * Update Count     : 632
  */
 …
                                 // numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
+length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
+size_opt (8|16|32|64|128)?
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
 integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
 …
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
+floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
+floating_size 32|64|80|128
+floating_length ([fFdDlL]|[lL]{floating_size})
+floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
 …
 finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
+__float128              { KEYWORD_RETURN(FLOAT); }                              // GCC
+__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
+float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
+__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
+float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
 for                             { KEYWORD_RETURN(FOR); }
 forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
 …
 __inline__              { KEYWORD_RETURN(INLINE); }                             // GCC
 int                             { KEYWORD_RETURN(INT); }
 __int128                { KEYWORD_RETURN(INT); }                                // GCC
 __int128_t              { KEYWORD_RETURN(INT); }                                // GCC
+__int128                { KEYWORD_RETURN(INT128); }                             // GCC
+int128                  { KEYWORD_RETURN(INT128); }                             // GCC
 __label__               { KEYWORD_RETURN(LABEL); }                              // GCC
 long                    { KEYWORD_RETURN(LONG); }
 …
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
-__uint128_t             { KEYWORD_RETURN(INT); }                                // GCC
 union                   { KEYWORD_RETURN(UNION); }
 unsigned                { KEYWORD_RETURN(UNSIGNED); }

src/Parser/parser.yy

-              rb96ec83
+              r6840e7c
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:07:12 2017
 // Update Count     : 2815
+// Last Modified On : Mon Oct 16 11:07:29 2017
+// Update Count     : 2892
 //
 …
 #define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
 #define YYDEBUG 1                                                                               // get the pretty debugging code to compile
 #define YYERROR_VERBOSE
+#define YYERROR_VERBOSE                                                                 // more information in syntax errors
 #undef __GNUC_MINOR__
 …
 bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
+# define YYLLOC_DEFAULT(Cur, Rhs, N)                            \
+do                                                              \
+        if (N) {                                                      \
+                (Cur).first_line   = YYRHSLOC(Rhs, 1).first_line;           \
+                (Cur).first_column = YYRHSLOC(Rhs, 1).first_column;         \
+                (Cur).last_line    = YYRHSLOC(Rhs, N).last_line;            \
+                (Cur).last_column  = YYRHSLOC(Rhs, N).last_column;          \
+                (Cur).filename     = YYRHSLOC(Rhs, 1).filename;             \
+        } else {                                                      \
+                (Cur).first_line   = (Cur).last_line   =                    \
+                        YYRHSLOC(Rhs, 0).last_line;                               \
+                (Cur).first_column = (Cur).last_column =                    \
+                        YYRHSLOC(Rhs, 0).last_column;                             \
+                (Cur).filename     = YYRHSLOC(Rhs, 0).filename;             \
+        }                                                             \
+while (0)
+// https://www.gnu.org/software/bison/manual/bison.html#Location-Type
+#define YYLLOC_DEFAULT(Cur, Rhs, N)                                                                                             \
+if ( N ) {                                                                                                                                              \
+        (Cur).first_line   = YYRHSLOC( Rhs, 1 ).first_line;                                                     \
+        (Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column;                                           \
+        (Cur).last_line    = YYRHSLOC( Rhs, N ).last_line;                                                      \
+        (Cur).last_column  = YYRHSLOC( Rhs, N ).last_column;                                            \
+        (Cur).filename     = YYRHSLOC( Rhs, 1 ).filename;                                                       \
+} else {                                                                                                                                                \
+        (Cur).first_line   = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line;            \
+        (Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column;        \
+        (Cur).filename     = YYRHSLOC( Rhs, 0 ).filename;                                                       \
+}
 %}
 %define parse.error verbose
 // Types declaration
+// Types declaration for productions
 %union
+{
 …
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
+%token INT128 FLOAT80 FLOAT128                                                  // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
 …
 %type<sn> exception_statement                   handler_clause                          finally_clause
 %type<catch_kind> handler_key
+%type<sn> mutex_statement
 %type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
 %type<sn> waitfor_statement
 …
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
-        | primary_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
-                        Token fn;
-                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
-                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { $$ = nullptr; }                                                               // FIX ME
 …
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
+        | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
+                        Token fn;
+                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
+                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
 …
         | jump_statement
         | with_statement
+        | mutex_statement
         | waitfor_statement
         | exception_statement
 …
+        ;
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+mutex_statement:
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
 when_clause:
         WHEN '(' comma_expression ')'
 …
         | VOLATILE
                 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
-        | MUTEX
-                { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
         | ATOMIC
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
 …
 basic_type_name:
+        CHAR
+        VOID
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+        | BOOL                                                                                          // C99
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+        | CHAR
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+        | INT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+        | INT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }
+        | FLOAT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+        | FLOAT80
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
+        | FLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
         | DOUBLE
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+        | FLOAT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+        | INT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+        | LONG
+                { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
+        | SHORT
+                { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+        | COMPLEX                                                                                       // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+        | IMAGINARY                                                                                     // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
         | SIGNED
                 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
         | UNSIGNED
                 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+        | VOID
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+        | BOOL                                                                                          // C99
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+        | COMPLEX                                                                                       // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+        | IMAGINARY                                                                                     // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+        | SHORT
+                { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+        | LONG
+                { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
         | ZERO_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
 …
         paren_identifier attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        | '&' MUTEX paren_identifier attribute_list_opt
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | identifier_parameter_ptr
         | identifier_parameter_array attribute_list_opt
 …
 //
 //              typedef int foo;
+//              forall( otype T ) foo( T );
 //              int f( int foo ); // redefine typedef name in new scope
 //
 …
         typedef attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        | '&' MUTEX typedef attribute_list_opt
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | type_parameter_ptr
         | type_parameter_array attribute_list_opt
 …
 abstract_parameter_declarator:
         abstract_parameter_ptr
+        | '&' MUTEX attribute_list_opt
+                { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
         | abstract_parameter_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }

src/ResolvExpr/AdjustExprType.cc

-              rb96ec83
+              r6840e7c
 //
+#include "Common/PassVisitor.h"
 #include "SymTab/Indexer.h"       // for Indexer
 #include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
 …
 namespace ResolvExpr {
+        class AdjustExprType : public Mutator {
+                typedef Mutator Parent;
+                using Parent::mutate;
+        class AdjustExprType : public WithShortCircuiting {
           public:
                 AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
+                void premutate( VoidType * ) { visit_children = false; }
+                void premutate( BasicType * ) { visit_children = false; }
+                void premutate( PointerType * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
+                void premutate( StructInstType * ) { visit_children = false; }
+                void premutate( UnionInstType * ) { visit_children = false; }
+                void premutate( EnumInstType * ) { visit_children = false; }
+                void premutate( TraitInstType * ) { visit_children = false; }
+                void premutate( TypeInstType * ) { visit_children = false; }
+                void premutate( TupleType * ) { visit_children = false; }
+                void premutate( VarArgsType * ) { visit_children = false; }
+                void premutate( ZeroType * ) { visit_children = false; }
+                void premutate( OneType * ) { visit_children = false; }
+                Type * postmutate( ArrayType *arrayType );
+                Type * postmutate( FunctionType *functionType );
+                Type * postmutate( TypeInstType *aggregateUseType );
           private:
-                virtual Type* mutate( VoidType *voidType );
-                virtual Type* mutate( BasicType *basicType );
-                virtual Type* mutate( PointerType *pointerType );
-                virtual Type* mutate( ArrayType *arrayType );
-                virtual Type* mutate( FunctionType *functionType );
-                virtual Type* mutate( StructInstType *aggregateUseType );
-                virtual Type* mutate( UnionInstType *aggregateUseType );
-                virtual Type* mutate( EnumInstType *aggregateUseType );
-                virtual Type* mutate( TraitInstType *aggregateUseType );
-                virtual Type* mutate( TypeInstType *aggregateUseType );
-                virtual Type* mutate( TupleType *tupleType );
-                virtual Type* mutate( VarArgsType *varArgsType );
-                virtual Type* mutate( ZeroType *zeroType );
-                virtual Type* mutate( OneType *oneType );
                 const TypeEnvironment &env;
                 const SymTab::Indexer &indexer;
 …
         void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
                 AdjustExprType adjuster( env, indexer );
+                PassVisitor<AdjustExprType> adjuster( env, indexer );
                 Type *newType = type->acceptMutator( adjuster );
                 type = newType;
 …
+        }
+        Type *AdjustExprType::mutate( VoidType *voidType ) {
+                return voidType;
+        }
+        Type *AdjustExprType::mutate( BasicType *basicType ) {
+                return basicType;
+        }
+        Type *AdjustExprType::mutate( PointerType *pointerType ) {
+                return pointerType;
+        }
+        Type *AdjustExprType::mutate( ArrayType *arrayType ) {
+        Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ) );
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
+                arrayType->base = nullptr;
                 delete arrayType;
                 return pointerType;
+        }
+        Type *AdjustExprType::mutate( FunctionType *functionType ) {
+                PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
+                return pointerType;
+        Type * AdjustExprType::postmutate( FunctionType * functionType ) {
+                return new PointerType( Type::Qualifiers(), functionType );
+        }
+        Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( TypeInstType *typeInst ) {
+        Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
                 EqvClass eqvClass;
                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
 …
                 return typeInst;
+        }
-        Type *AdjustExprType::mutate( TupleType *tupleType ) {
-                return tupleType;
+        }
-        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
-                return varArgsType;
+        }
-        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
-                return zeroType;
+        }
-        Type *AdjustExprType::mutate( OneType *oneType ) {
-                return oneType;
+        }
 } // namespace ResolvExpr

src/ResolvExpr/Alternative.cc

-              rb96ec83
+              r6840e7c
+        }
         void Alternative::print( std::ostream &os, int indent ) const {
                 os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
+        void Alternative::print( std::ostream &os, Indenter indent ) const {
+                os << "Cost " << cost << ": ";
                 if ( expr ) {
                         expr->print( os, indent );
                         os << "(types:" << std::endl;
                         os << std::string( indent+4, ' ' );
                         expr->get_result()->print( os, indent + 4 );
                         os << std::endl << ")" << std::endl;
+                        expr->print( os, indent+1 );
+                        os << std::endl << indent << "(types:" << std::endl;
+                        os << indent+1;
+                        expr->result->print( os, indent+1 );
+                        os << std::endl << indent << ")" << std::endl;
                 } else {
                         os << "Null expression!" << std::endl;
                 } // if
                 os << std::string( indent, ' ' ) << "Environment: ";
                 env.print( os, indent+2 );
+                os << indent << "Environment: ";
+                env.print( os, indent+1 );
                 os << std::endl;
+        }

src/ResolvExpr/Alternative.h

rb96ec83	r6840e7c
39	39	~Alternative();
40	40
41		void print( std::ostream &os, ~~int indent = 0~~ ) const;
	41	void print( std::ostream &os, Indenter indent = {} ) const;
42	42
43	43	Cost cost;

src/ResolvExpr/AlternativeFinder.cc

-              rb96ec83
+              r6840e7c
         namespace {
+                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
+                void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
+                        Indenter indent = { Indenter::tabsize, indentAmt };
                         for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
                                 i->print( os, indent );
 …
                                 AltList winners;
                                 findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                                 stream << "Cannot choose between " << winners.size() << " alternatives for expression ";
+                                stream << "Cannot choose between " << winners.size() << " alternatives for expression\n";
                                 expr->print( stream );
                                 stream << "Alternatives are:";
                                 printAlts( winners, stream, 8 );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
                                 throw SemanticError( stream.str() );
+                        }
 …
                                 Alternative newerAlt( newAlt );
                                 newerAlt.env = newEnv;
                                 assert( (*candidate)->get_uniqueId() );
+                                assertf( (*candidate)->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( *candidate ).c_str() );
                                 DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
 …
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;
                         printAlts( funcOpFinder.alternatives, std::cerr, 8 );
+                        printAlts( funcOpFinder.alternatives, std::cerr, 1 );
+                )
 …
         bool isLvalue( Expression *expr ) {
                 // xxx - recurse into tuples?
                 return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+                return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+        }
 …
                 PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
+                        VariableExpr newExpr( *i );
                         alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
 …
                 // O(N^2) checks of d-types with e-types
                 for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
                         Type * toType = resolveTypeof( initAlt.type, indexer );
+                        Type * toType = resolveTypeof( initAlt.type->clone(), indexer );
                         SymTab::validateType( toType, &indexer );
                         adjustExprType( toType, env, indexer );

src/ResolvExpr/CastCost.cc

-              rb96ec83
+              r6840e7c
 #include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 namespace ResolvExpr {
 …
                         } // if
                 } // if
+                PRINT(
+                        std::cerr << "castCost ::: src is ";
+                        src->print( std::cerr );
+                        std::cerr << std::endl << "dest is ";
+                        dest->print( std::cerr );
+                        std::cerr << std::endl << "env is" << std::endl;
+                        env.print( std::cerr, 8 );
+                )
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+                        PRINT( std::cerr << "compatible!" << std::endl; )
                         return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
                         return Cost::safe;
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
                                 return ptrsCastable( t1, t2, env, indexer );

src/ResolvExpr/CommonType.cc

-              rb96ec83
+              r6840e7c
 // Created On       : Sun May 17 06:59:27 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 16:24:31 2017
 // Update Count     : 7
+// Last Modified On : Mon Sep 25 15:18:17 2017
+// Update Count     : 9
 //
 …
         static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
+/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary */
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }
+/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary   SignedInt128   UnsignedInt128 */
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Float,       BasicType::Float, },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Double,      BasicType::Double, },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDouble,  BasicType::LongDouble, },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::FloatComplex, },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex, },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex, },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::FloatImaginary,      BasicType::FloatImaginary, },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::DoubleImaginary,     BasicType::DoubleImaginary, },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary },
+                /* SignedInt128 */      { BasicType::SignedInt128,      BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedInt128 */    { BasicType::UnsignedInt128,    BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::UnsignedInt128,      BasicType::UnsignedInt128, },
         };

src/ResolvExpr/ConversionCost.cc

-              rb96ec83
+              r6840e7c
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:35:46 2016
 // Update Count     : 6
+// Last Modified On : Mon Sep 25 15:43:34 2017
+// Update Count     : 10
 //
 …
 */
+        static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
+        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag */
+                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              10,             11,             12,             11,             12,             13,             -1,             -1,             -1 },
+                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              9,              10,             11,             10,             11,             12,             -1,             -1,             -1 },
+                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              9,              10,             11,             10,             11,             12,             -1,             -1,             -1 },
+                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              8,              9,              10,             9,              10,             11,             -1,             -1,             -1 },
+                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              7,              8,              9,              8,              9,              10,             -1,             -1,             -1 },
+                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              6,              7,              8,              7,              8,              9,              -1,             -1,             -1 },
+                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              5,              6,              7,              6,              7,              8,              -1,             -1,             -1 },
+                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              4,              5,              6,              5,              6,              7,              -1,             -1,             -1 },
+                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              5,              6,              5,              6,              7,              -1,             -1,             -1 },
+                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              5,              4,              5,              6,              -1,             -1,             -1 },
+                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              3,              4,              5,              -1,             -1,             -1 },
+                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              2,              3,              4,              -1,             -1,             -1 },
+                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1 },
+                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1 },
+                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1 },
+                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1 },
+                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1 },
+                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1 },
+                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2 },
+                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1 },
+                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0 }
+        static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = {
+        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag  I128,   U128 */
+                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              12,             13,             14,             12,             13,             14,             -1,             -1,             -1,             10,             11,     },
+                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,     },
+                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,     },
+                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              10,             11,             12,             10,             11,             12,             -1,             -1,             -1,             8,              9,      },
+                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              9,              10,             11,             9,              10,             11,             -1,             -1,             -1,             7,              8,      },
+                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              8,              9,              10,             8,              9,              10,             -1,             -1,             -1,             6,              7,      },
+                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              7,              8,              9,              7,              8,              9,              -1,             -1,             -1,             5,              6,      },
+                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,      },
+                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,      },
+                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              5,              6,              7,              5,              6,              7,              -1,             -1,             -1,             3,              4,      },
+                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              4,              5,              6,              4,              5,              6,              -1,             -1,             -1,             2,              3,      },
+                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              3,              4,              5,              3,              4,              5,              -1,             -1,             -1,             1,              2,      },
+                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1,             -1,             -1,     },
+                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1,             -1,             -1,     },
+                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,     },
+                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1,             -1,             -1,     },
+                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1,             -1,             -1,     },
+                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1,             -1,             -1,     },
+                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2,              -1,             -1,     },
+                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1,              -1,             -1,     },
+                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0,              -1,             -1,     },
+                /* I128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             2,              3,              4,              3,              4,              5,              -1,             -1,             -1,             0,              1,      },
+                /* U128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              2,              3,              4,              -1,             -1,             -1,             -1,             0,      },
         };
 …
                 // recursively compute conversion cost from T1 to T2.
                 // cv can be safely dropped because of 'implicit dereference' behavior.
                 refType->get_base()->accept( *this );
                 if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) {
+                refType->base->accept( *this );
+                if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
                         cost.incReference();  // prefer exact qualifiers
                 } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) {
+                } else if ( refType->base->get_qualifiers() < dest->get_qualifiers() ) {
                         cost.incSafe(); // then gaining qualifiers
                 } else {
 …
         void ConversionCost::visit(StructInstType *inst) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->get_name() == destAsInst->get_name() ) {
+                        if ( inst->name == destAsInst->name ) {
                                 cost = Cost::zero;
                         } // if
 …
         void ConversionCost::visit(UnionInstType *inst) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->get_name() == destAsInst->get_name() ) {
+                if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
+                        if ( inst->name == destAsInst->name ) {
                                 cost = Cost::zero;
                         } // if

src/ResolvExpr/ResolveTypeof.cc

-              rb96ec83
+              r6840e7c
 #include <cassert>               // for assert
+#include "Common/PassVisitor.h"  // for PassVisitor
 #include "Resolver.h"            // for resolveInVoidContext
 #include "SynTree/Expression.h"  // for Expression
 …
+        }
         class ResolveTypeof : public Mutator {
+        class ResolveTypeof : public WithShortCircuiting {
           public:
                 ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
+                Type *mutate( TypeofType *typeofType );
+                void premutate( TypeofType *typeofType );
+                Type * postmutate( TypeofType *typeofType );
           private:
 …
         };
         Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
                 ResolveTypeof mutator( indexer );
+        Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
+                PassVisitor<ResolveTypeof> mutator( indexer );
                 return type->acceptMutator( mutator );
+        }
+        Type *ResolveTypeof::mutate( TypeofType *typeofType ) {
+        void ResolveTypeof::premutate( TypeofType * ) {
+                visit_children = false;
+        }
+        Type * ResolveTypeof::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cout << "resolving typeof: ";
                 typeofType->print( std::cout );
                 std::cout << std::endl;
+                std::cerr << "resolving typeof: ";
+                typeofType->print( std::cerr );
+                std::cerr << std::endl;
 #endif
                 if ( typeofType->get_expr() ) {
                         Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
                         assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
                         Type *newType = newExpr->get_result();
                         newExpr->set_result( nullptr );
+                if ( typeofType->expr ) {
+                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
+                        assert( newExpr->result && ! newExpr->result->isVoid() );
+                        Type * newType = newExpr->result;
+                        newExpr->result = nullptr;
                         delete typeofType;
                         delete newExpr;

src/ResolvExpr/Resolver.cc

-              rb96ec83
+              r6840e7c
                 void previsit( FunctionDecl *functionDecl );
                 void postvisit( FunctionDecl *functionDecl );
                 void previsit( ObjectDecl *functionDecl );
+                void previsit( ObjectDecl *objectDecll );
                 void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
 …
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
                         expr->set_env( new TypeSubstitution );
+                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                        expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->get_env() );
+                }
+                void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
+                                        // cast is to the same type as its argument, so it's unnecessary -- remove it
+                                        expr = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( expr->env, castExpr->env );
+                                        delete castExpr;
+                                }
+                        }
+                }
         } // namespace
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 global_renamer.reset();
                 TypeEnvironment env;
                 Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                finishExpr( newExpr, env );
+                return newExpr;
+        }
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                finishExpr( newExpr, env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
+                if ( ! untyped ) return;
                 TypeEnvironment env;
                 AlternativeFinder finder( indexer, env );
 …
                 #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 );
+                        std::cerr << "untyped expr is ";
+                        untyped->print( std::cerr );
+                        std::cerr << std::endl << "alternatives are:";
+                        for ( const Alternative & alt : finder.get_alternatives() ) {
+                                alt.print( std::cerr );
                         } // for
                 } // if
 …
                 Alternative &choice = finder.get_alternatives().front();
                 Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env );
+                return newExpr;
+                finishExpr( newExpr, choice.env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
+                assert( untyped && type );
+                untyped = new CastExpr( untyped, type );
+                findSingleExpression( untyped, indexer );
+                removeExtraneousCast( untyped, indexer );
+        }
 …
+                }
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
 …
                                 throw SemanticError( "No interpretations for case control expression", untyped );
                         } // if
+                        finishExpr( newExpr, *newEnv );
+                        return newExpr;
+                        finishExpr( newExpr, *newEnv, untyped->env );
+                        delete untyped;
+                        untyped = newExpr;
+                }
 …
         void Resolver::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
+                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        delete type->get_dimension();
+                        type->set_dimension( newExpr );
+                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
+                }
+        }
 …
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+        }
         void Resolver::postvisit( FunctionDecl *functionDecl ) {
 …
         void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
+                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
+                delete exprStmt->get_expr();
+                exprStmt->set_expr( newExpr );
+                assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
+                findVoidExpression( exprStmt->expr, indexer );
+        }
         void Resolver::previsit( AsmExpr *asmExpr ) {
                 visit_children = false;
+                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
+                delete asmExpr->get_operand();
+                asmExpr->set_operand( newExpr );
+                findVoidExpression( asmExpr->operand, indexer );
                 if ( asmExpr->get_inout() ) {
+                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
+                        delete asmExpr->get_inout();
+                        asmExpr->set_inout( newExpr );
+                        findVoidExpression( asmExpr->inout, indexer );
                 } // if
+        }
 …
         void Resolver::previsit( IfStmt *ifStmt ) {
+                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
+                delete ifStmt->get_condition();
+                ifStmt->set_condition( newExpr );
+                findSingleExpression( ifStmt->condition, indexer );
+        }
         void Resolver::previsit( WhileStmt *whileStmt ) {
+                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
+                delete whileStmt->get_condition();
+                whileStmt->set_condition( newExpr );
+                findSingleExpression( whileStmt->condition, indexer );
+        }
         void Resolver::previsit( ForStmt *forStmt ) {
+                if ( forStmt->get_condition() ) {
+                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
+                        delete forStmt->get_condition();
+                        forStmt->set_condition( newExpr );
+                if ( forStmt->condition ) {
+                        findSingleExpression( forStmt->condition, indexer );
                 } // if
+                if ( forStmt->get_increment() ) {
+                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
+                        delete forStmt->get_increment();
+                        forStmt->set_increment( newExpr );
+                if ( forStmt->increment ) {
+                        findVoidExpression( forStmt->increment, indexer );
                 } // if
+        }
 …
         void Resolver::previsit( SwitchStmt *switchStmt ) {
                 GuardValue( currentObject );
+                Expression *newExpr;
+                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
+                delete switchStmt->get_condition();
+                switchStmt->set_condition( newExpr );
+                currentObject = CurrentObject( newExpr->get_result() );
+                findIntegralExpression( switchStmt->condition, indexer );
+                currentObject = CurrentObject( switchStmt->condition->result );
+        }
 …
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
+                        Expression * newExpr = findSingleExpression( castExpr, indexer );
+                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
+                        caseStmt->set_condition( castExpr->get_arg() );
+                        castExpr->set_arg( nullptr );
+                        // must remove cast from case statement because RangeExpr cannot be cast.
+                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
+                        findSingleExpression( newExpr, indexer );
+                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
+                        caseStmt->condition = castExpr->arg;
+                        castExpr->arg = nullptr;
                         delete castExpr;
+                }
 …
                 // must resolve the argument for a computed goto
                 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
+                        if ( Expression * arg = branchStmt->get_computedTarget() ) {
+                                VoidType v = Type::Qualifiers();                // cast to void * for the alternative finder
+                                PointerType pt( Type::Qualifiers(), v.clone() );
+                                CastExpr * castExpr = new CastExpr( arg, pt.clone() );
+                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
+                                branchStmt->set_target( newExpr );
+                        if ( branchStmt->computedTarget ) {
+                                // computed goto argument is void *
+                                findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
                         } // if
                 } // if
 …
         void Resolver::previsit( ReturnStmt *returnStmt ) {
                 visit_children = false;
+                if ( returnStmt->get_expr() ) {
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        delete castExpr;
+                        returnStmt->set_expr( newExpr );
+                if ( returnStmt->expr ) {
+                        findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
                 } // if
+        }
 …
                                 indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
+                        Expression * wrapped = new CastExpr(
+                                throwStmt->get_expr(),
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                exception_decl
+                                                )
+                                        )
+                                );
+                        Expression * newExpr = findSingleExpression( wrapped, indexer );
+                        throwStmt->set_expr( newExpr );
+                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
+                        findSingleExpression( throwStmt->expr, exceptType, indexer );
+                }
+        }
         void Resolver::previsit( CatchStmt *catchStmt ) {
+                if ( catchStmt->get_cond() ) {
+                        Expression * wrapped = new CastExpr(
+                                catchStmt->get_cond(),
+                                new BasicType( noQualifiers, BasicType::Bool )
+                                );
+                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
+                }
+        }
+        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;
+                if ( catchStmt->cond ) {
+                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                }
+        }
 …
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
                         resolveAsIf( clause.condition, this->indexer );
+                        findSingleExpression( clause.condition, this->indexer );
                         clause.statement->accept( *visitor );
+                }
 …
                         // 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 );
+                        findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        findSingleExpression( stmt->timeout.condition, this->indexer );
                         stmt->timeout.statement->accept( *visitor );
+                }
 …
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
                         resolveAsIf( stmt->orelse.condition, this->indexer );
+                        findSingleExpression( stmt->orelse.condition, this->indexer );
                         stmt->orelse.statement->accept( *visitor );
+                }
 …
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
                 Expression * newExpr = findSingleExpression( untyped, indexer );
+                Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() );
+                findSingleExpression( newExpr, indexer );
                 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 …
                 // discard InitExpr wrapper and retain relevant pieces
+                newExpr = initExpr->get_expr();
+                newExpr->set_env( initExpr->get_env() );
+                initExpr->set_expr( nullptr );
+                initExpr->set_env( nullptr );
+                newExpr = initExpr->expr;
+                initExpr->expr = nullptr;
+                std::swap( initExpr->env, newExpr->env );
                 delete initExpr;
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
                 Type * initContext = currentObject.getCurrentType();
+                removeExtraneousCast( newExpr, indexer );
                 // check if actual object's type is char[]
 …
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
+                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                        newExpr = ce->get_arg();
+                                                        ce->set_arg( nullptr );
+                                                        std::swap( ce->env, newExpr->env );
+                                                        delete ce;
+                                                }
+                                        }
+                                }
 …
                 // set initializer expr to resolved express
                 singleInit->set_value( newExpr );
+                singleInit->value = newExpr;
                 // move cursor to next object in preparation for next initializer

src/ResolvExpr/Resolver.h

-              rb96ec83
+              r6840e7c
         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 );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void 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

-              rb96ec83
+              r6840e7c
+        }
         void EqvClass::print( std::ostream &os, int indent ) const {
                 os << std::string( indent, ' ' ) << "( ";
+        void EqvClass::print( std::ostream &os, Indenter indent ) const {
+                os << "( ";
                 std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
                 os << ")";
                 if ( type ) {
                         os << " -> ";
                         type->print( os, indent );
+                        type->print( os, indent+1 );
                 } // if
                 if ( ! allowWidening ) {
 …
+        }
         void TypeEnvironment::print( std::ostream &os, int indent ) const {
+        void TypeEnvironment::print( std::ostream &os, Indenter indent ) const {
                 for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
                         i->print( os, indent );

src/ResolvExpr/TypeEnvironment.h

-              rb96ec83
+              r6840e7c
                 EqvClass &operator=( const EqvClass &other );
                 ~EqvClass();
                 void print( std::ostream &os, int indent = 0 ) const;
+                void print( std::ostream &os, Indenter indent = {} ) const;
         };
 …
                 void makeSubstitution( TypeSubstitution &result ) const;
                 bool isEmpty() const { return env.empty(); }
                 void print( std::ostream &os, int indent = 0 ) const;
+                void print( std::ostream &os, Indenter indent = {} ) const;
                 void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
                 void simpleCombine( const TypeEnvironment &second );

src/ResolvExpr/Unify.cc

-              rb96ec83
+              r6840e7c
 #include <utility>                // for pair
+#include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
 #include "Parser/LinkageSpec.h"   // for C
 …
         /// If this isn't done then argument lists can have wildly different
         /// size and structure, when they should be compatible.
+        struct TtypeExpander : public Mutator {
+                TypeEnvironment & env;
+                TtypeExpander( TypeEnvironment & env ) : env( env ) {}
+                Type * mutate( TypeInstType * typeInst ) {
+        struct TtypeExpander : public WithShortCircuiting {
+                TypeEnvironment & tenv;
+                TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
+                void premutate( TypeInstType * ) { visit_children = false; }
+                Type * postmutate( TypeInstType * typeInst ) {
                         EqvClass eqvClass;
                         if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.data.kind == TypeDecl::Ttype ) {
                                         // expand ttype parameter into its actual type
 …
                 dst.clear();
                 for ( DeclarationWithType * dcl : src ) {
                         TtypeExpander expander( env );
+                        PassVisitor<TtypeExpander> expander( env );
                         dcl->acceptMutator( expander );
                         std::list< Type * > types;
 …
                         std::list<Type *> types1, types2;
                         TtypeExpander expander( env );
+                        PassVisitor<TtypeExpander> expander( env );
                         flat1->acceptMutator( expander );
                         flat2->acceptMutator( expander );

src/SymTab/Autogen.cc

-              rb96ec83
+              r6840e7c
 namespace SymTab {
         Type * SizeType = 0;
+        typedef ScopedMap< std::string, bool > TypeMap;
+        /// Data used to generate functions generically. Specifically, the name of the generated function, a function which generates the routine protoype, and a map which contains data to determine whether a function should be generated.
+        /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
         struct FuncData {
                 typedef FunctionType * (*TypeGen)( Type * );
                 FuncData( const std::string & fname, const TypeGen & genType, TypeMap & map ) : fname( fname ), genType( genType ), map( map ) {}
+                FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
                 std::string fname;
                 TypeGen genType;
+                TypeMap & map;
+        };
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
+        };
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting, public WithIndexer {
                 AutogenerateRoutines();
 …
           private:
                 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
+                /// deleted functions in if they are maps, since the value false can be inserted
+                /// at the current scope without affecting outer scopes or requiring copies.
+                TypeMap copyable, assignable, constructable, destructable;
+                InitTweak::ManagedTypes managedTypes;
                 std::vector< FuncData > data;
         };
 …
         /// generates routines for tuple types.
         struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
                 void previsit( FunctionDecl *functionDecl );
                 void postvisit( TupleType *tupleType );
                 void previsit( CompoundStmt *compoundStmt );
+                void previsit( FunctionDecl * functionDecl );
+                void postvisit( TupleType * tupleType );
+                void previsit( CompoundStmt * compoundStmt );
           private:
 …
+        }
+        //=============================================================================================
+        // FuncGenerator definitions
+        //=============================================================================================
+        class FuncGenerator {
+        public:
+                std::list< Declaration * > definitions, forwards;
+                FuncGenerator( Type * type, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : type( type ), data( data ), functionNesting( functionNesting ), indexer( indexer ) {}
+                virtual bool shouldAutogen() const = 0;
+                void genStandardFuncs();
+                virtual void genFieldCtors() = 0;
+        protected:
+                Type * type;
+                const std::vector< FuncData > & data;
+                unsigned int functionNesting;
+                SymTab::Indexer & indexer;
+                virtual void genFuncBody( FunctionDecl * dcl ) = 0;
+                virtual bool isConcurrentType() const = 0;
+                void resolve( FunctionDecl * dcl );
+                void generatePrototypes( std::list< FunctionDecl * > & newFuncs );
+        };
+        class StructFuncGenerator : public FuncGenerator {
+                StructDecl * aggregateDecl;
+        public:
+                StructFuncGenerator( StructDecl * aggregateDecl, StructInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+                /// generates a single struct member operation (constructor call, destructor call, assignment call)
+                void makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true );
+                /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                template<typename Iterator>
+                void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true );
+                /// generate the body of a constructor which takes parameters that match fields, e.g.
+                /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+                template<typename Iterator>
+                void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func );
+        };
+        class UnionFuncGenerator : public FuncGenerator {
+                UnionDecl * aggregateDecl;
+        public:
+                UnionFuncGenerator( UnionDecl * aggregateDecl, UnionInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+                /// generates a single struct member operation (constructor call, destructor call, assignment call)
+                template<typename OutputIterator>
+                void makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out );
+                /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                template<typename Iterator>
+                void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true );
+                /// generate the body of a constructor which takes parameters that match fields, e.g.
+                /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+                template<typename Iterator>
+                void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func );
+        };
+        class EnumFuncGenerator : public FuncGenerator {
+        public:
+                EnumFuncGenerator( EnumInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+        };
+        class TypeFuncGenerator : public FuncGenerator {
+                TypeDecl * typeDecl;
+        public:
+                TypeFuncGenerator( TypeDecl * typeDecl, TypeInstType * refType, const std::vector<FuncData> & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), typeDecl( typeDecl ) {}
+                virtual bool shouldAutogen() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFieldCtors() override;
+        };
+        //=============================================================================================
+        // helper functions
+        //=============================================================================================
+        void generateFunctions( FuncGenerator & gen, std::list< Declaration * > & declsToAdd ) {
+                if ( ! gen.shouldAutogen() ) return;
+                // generate each of the functions based on the supplied FuncData objects
+                gen.genStandardFuncs();
+                gen.genFieldCtors();
+                declsToAdd.splice( declsToAdd.end(), gen.forwards );
+                declsToAdd.splice( declsToAdd.end(), gen.definitions );
+        }
         bool isUnnamedBitfield( ObjectDecl * obj ) {
                 return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
+                return obj != nullptr && obj->name == "" && obj->bitfieldWidth != nullptr;
+        }
 …
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
                 decl->set_statements( nullptr );
+                delete decl->statements;
+                decl->statements = nullptr;
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
+        }
+        const std::list< TypeDecl * > getGenericParams( Type * t ) {
+                std::list< TypeDecl * > * ret = nullptr;
+                if ( StructInstType * inst = dynamic_cast< StructInstType * > ( t ) ) {
+                        ret = inst->get_baseParameters();
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                        ret = inst->get_baseParameters();
+                }
+                return ret ? *ret : std::list< TypeDecl * >();
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType ) {
+                const auto & typeParams = getGenericParams( paramType );
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
+                cloneAll( typeParams, ftype->forall );
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->get_parameters().push_back( dstParam );
+                ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
 …
                 FunctionType *ftype = genDefaultType( paramType );
                 ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->get_parameters().push_back( srcParam );
+                ftype->parameters.push_back( srcParam );
                 return ftype;
+        }
 …
                 FunctionType *ftype = genCopyType( paramType );
                 ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->get_returnVals().push_back( returnVal );
+                ftype->returnVals.push_back( returnVal );
                 return ftype;
+        }
 …
+        }
+        /// inserts base type of first argument into map if pred(funcDecl) is true
+        void insert( FunctionDecl *funcDecl, TypeMap & map, FunctionDecl * (*pred)(Declaration *) ) {
+                // insert type into constructable, etc. map if appropriate
+                if ( pred( funcDecl ) ) {
+                        FunctionType * ftype = funcDecl->get_functionType();
+                        assert( ! ftype->get_parameters().empty() );
+                        Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
+                        assert( t );
+                        map.insert( Mangler::mangleType( t ), true );
+                }
+        }
+        /// using map and t, determines if is constructable, etc.
+        bool lookup( const TypeMap & map, Type * t ) {
+                assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() );
+                if ( dynamic_cast< PointerType * >( t ) ) {
+                        // will need more complicated checking if we want this to work with pointer types, since currently
+                        return true;
+                } else if ( ArrayType * at = dynamic_cast< ArrayType * >( t ) ) {
+                        // an array's constructor, etc. is generated on the fly based on the base type's constructor, etc.
+                        return lookup( map, at->get_base() );
+                }
+                TypeMap::const_iterator it = map.find( Mangler::mangleType( t ) );
+                if ( it != map.end() ) return it->second;
+                // something that does not appear in the map is by default not constructable, etc.
+                return false;
+        }
+        /// using map and aggr, examines each member to determine if constructor, etc. should be generated
+        template<typename Container>
+        bool shouldGenerate( const TypeMap & map, const Container & container ) {
+                for ( Type * t : container ) {
+                        if ( ! lookup( map, t ) ) return false;
+                }
+                return true;
+        }
+        /// data structure for abstracting the generation of special functions
+        template< typename OutputIterator, typename Container >
+        struct FuncGenerator {
+                const Container & container;
+                Type *refType;
+                unsigned int functionNesting;
+                const std::list< TypeDecl* > & typeParams;
+                OutputIterator out;
+                FuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : container( container ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {}
+                /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
+                void gen( const FuncData & data, bool concurrent_type ) {
+                        if ( ! shouldGenerate( data.map, container ) ) return;
+                        FunctionType * ftype = data.genType( refType );
+        Type * declToType( Declaration * decl ) {
+                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        return dwt->get_type();
+                }
+                return nullptr;
+        }
+        Type * declToTypeDeclBase( Declaration * decl ) {
+                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
+                        return td->base;
+                }
+                return nullptr;
+        }
+        //=============================================================================================
+        // FuncGenerator member definitions
+        //=============================================================================================
+        void FuncGenerator::genStandardFuncs() {
+                std::list< FunctionDecl * > newFuncs;
+                generatePrototypes( newFuncs );
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        genFuncBody( dcl );
+                        if ( CodeGen::isAssignment( dcl->name ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->type;
+                                assert( assignType->parameters.size() == 2 );
+                                assert( assignType->returnVals.size() == 1 );
+                                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() );
+                                dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) );
+                        }
+                        resolve( dcl );
+                }
+        }
+        void FuncGenerator::generatePrototypes( std::list< FunctionDecl * > & newFuncs ) {
+                bool concurrent_type = isConcurrentType();
+                for ( const FuncData & data : data ) {
+                        // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
+                        FunctionType * ftype = data.genType( type );
+                        // destructor for concurrent type must be mutex
                         if ( concurrent_type && CodeGen::isDestructor( data.fname ) ) {
                                 ftype->parameters.front()->get_type()->set_mutex( true );
+                        }
+                        cloneAll( typeParams, ftype->forall );
+                        *out++ = genFunc( data.fname, ftype, functionNesting );
+                        data.map.insert( Mangler::mangleType( refType ), true );
+                }
+        };
+        template< typename OutputIterator, typename Container >
+        FuncGenerator<OutputIterator, Container> makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
+                return FuncGenerator<OutputIterator, Container>( container, refType, functionNesting, typeParams, out );
+        }
+        /// generates a single enumeration assignment expression
+        ApplicationExpr * genEnumAssign( FunctionType * ftype, FunctionDecl * assignDecl ) {
+                // enum copy construct and assignment is just C-style assignment.
+                // this looks like a bad recursive call, but code gen will turn it into
+                // a C-style assignment.
+                // This happens before function pointer type conversion, so need to do it manually here
+                // NOTE: ftype is not necessarily the functionType belonging to assignDecl - ftype is the
+                // type of the function that this expression is being generated for (so that the correct
+                // parameters) are using in the variable exprs
+                assert( ftype->get_parameters().size() == 2 );
+                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+                VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
+                Type * assignVarExprType = assignVarExpr->get_result();
+                assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
+                assignVarExpr->set_result( assignVarExprType );
+                ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
+                assignExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                assignExpr->get_args().push_back( new VariableExpr( srcParam ) );
+                return assignExpr;
+        }
+        // E ?=?(E volatile*, int),
+        //   ?=?(E _Atomic volatile*, int);
+        void makeEnumFunctions( EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+                // T ?=?(E *, E);
+                FunctionType *assignType = genAssignType( refType );
+                // void ?{}(E *); void ^?{}(E *);
+                FunctionType * ctorType = genDefaultType( refType->clone() );
+                FunctionType * dtorType = genDefaultType( refType->clone() );
+                // void ?{}(E *, E);
+                FunctionType *copyCtorType = genCopyType( refType->clone() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
+                // right now these cases work, but that might change.
+                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
+                // Really they're something of a cross between instrinsic and autogen, so should
+                // probably make a new linkage type
+                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting, true );
+                FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting, true );
+                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting, true );
+                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting, true );
+                // body is either return stmt or expr stmt
+                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, genEnumAssign( assignType, assignDecl ) ) );
+                copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, genEnumAssign( copyCtorType, assignDecl ) ) );
+                declsToAdd.push_back( ctorDecl );
+                declsToAdd.push_back( copyCtorDecl );
+                declsToAdd.push_back( dtorDecl );
+                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+        /// generates a single struct member operation (constructor call, destructor call, assignment call)
+        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) {
+                        newFuncs.push_back( genFunc( data.fname, ftype, functionNesting ) );
+                }
+        }
+        void FuncGenerator::resolve( FunctionDecl * dcl ) {
+                try {
+                        ResolvExpr::resolveDecl( dcl, indexer );
+                        if ( functionNesting == 0 ) {
+                                // forward declare if top-level struct, so that
+                                // type is complete as soon as its body ends
+                                // Note: this is necessary if we want structs which contain
+                                // generic (otype) structs as members.
+                                addForwardDecl( dcl, forwards );
+                        }
+                        definitions.push_back( dcl );
+                        indexer.addId( dcl );
+                } catch ( SemanticError err ) {
+                        // okay if decl does not resolve - that means the function should not be generated
+                        delete dcl;
+                }
+        }
+        bool StructFuncGenerator::shouldAutogen() const {
+                // Builtins do not use autogeneration.
+                return ! aggregateDecl->linkage.is_builtin;
+        }
+        bool StructFuncGenerator::isConcurrentType() const { return aggregateDecl->is_thread() || aggregateDecl->is_monitor(); }
+        void StructFuncGenerator::genFuncBody( FunctionDecl * dcl ) {
+                // generate appropriate calls to member ctor, assignment
+                // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                if ( ! CodeGen::isDestructor( dcl->name ) ) {
+                        makeFunctionBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), dcl );
+                } else {
+                        makeFunctionBody( aggregateDecl->members.rbegin(), aggregateDecl->members.rend(), dcl, false );
+                }
+        }
+        void StructFuncGenerator::genFieldCtors() {
+                // field ctors are only generated if default constructor and copy constructor are both generated
+                unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->name ); } );
+                // Field constructors are only generated if default and copy constructor
+                // are generated, since they need access to both
+                if ( numCtors != 2 ) return;
+                // create constructors which take each member type as a parameter.
+                // for example, for struct A { int x, y; }; generate
+                //   void ?{}(A *, int) and void ?{}(A *, int, int)
+                FunctionType * memCtorType = genDefaultType( type );
+                for ( Declaration * member : aggregateDecl->members ) {
+                        DeclarationWithType * field = strict_dynamic_cast<DeclarationWithType *>( member );
+                        if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) {
+                                // don't make a function whose parameter is an unnamed bitfield
+                                continue;
+                        }
+                        memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ) );
+                        FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                        makeFieldCtorBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), ctor );
+                        resolve( ctor );
+                }
+                delete memCtorType;
+        }
+        void StructFuncGenerator::makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward ) {
                 InitTweak::InitExpander srcParam( src );
                 // assign to destination
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
+                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+        }
+        /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->base->clone() ) );
+                genImplicitCall( srcParam, dstselect, func->name, back_inserter( func->statements->kids ), field, forward );
+        }
         template<typename Iterator>
         void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) {
+        void StructFuncGenerator::makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward ) {
                 for ( ; member != end; ++member ) {
                         if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate
 …
+                                }
                                 if ( type->get_const() && func->get_name() == "?=?" ) {
+                                if ( type->get_const() && CodeGen::isAssignment( func->name ) ) {
                                         // don't assign const members, but do construct/destruct
-                                        continue;
+                                }
-                                if ( field->get_name() == "" ) {
-                                        // don't assign to anonymous members
-                                        // xxx - this is a temporary fix. Anonymous members tie into
-                                        // our inheritance model. I think the correct way to handle this is to
-                                        // cast the structure to the type of the member and let the resolver
-                                        // figure out whether it's valid and have a pass afterwards that fixes
-                                        // the assignment to use pointer arithmetic with the offset of the
-                                        // member, much like how generic type members are handled.
                                         continue;
+                                }
 …
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
+                                }
                                 // srcParam may be NULL, in which case we have default ctor/dtor
                                 assert( dstParam );
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
+                                makeMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
                 } // for
+        } // makeStructFunctionBody
+        /// generate the body of a constructor which takes parameters that match fields, e.g.
+        /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+        } // makeFunctionBody
         template<typename Iterator>
         void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) {
                 FunctionType * ftype = func->get_functionType();
                 std::list<DeclarationWithType*> & params = ftype->get_parameters();
+        void StructFuncGenerator::makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) {
+                FunctionType * ftype = func->type;
+                std::list<DeclarationWithType*> & params = ftype->parameters;
                 assert( params.size() >= 2 );  // should not call this function for default ctor, etc.
 …
                                         // don't make a function whose parameter is an unnamed bitfield
                                         continue;
-                                } else if ( field->get_name() == "" ) {
-                                        // don't assign to anonymous members
-                                        // xxx - this is a temporary fix. Anonymous members tie into
-                                        // our inheritance model. I think the correct way to handle this is to
-                                        // cast the structure to the type of the member and let the resolver
-                                        // figure out whether it's valid and have a pass afterwards that fixes
-                                        // the assignment to use pointer arithmetic with the offset of the
-                                        // member, much like how generic type members are handled.
-                                        continue;
                                 } else if ( parameter != params.end() ) {
                                         // matching parameter, initialize field with copy ctor
                                         Expression *srcselect = new VariableExpr(*parameter);
                                         makeStructMemberOp( dstParam, srcselect, field, func );
+                                        makeMemberOp( dstParam, srcselect, field, func );
                                         ++parameter;
                                 } else {
                                         // no matching parameter, initialize field with default ctor
                                         makeStructMemberOp( dstParam, nullptr, field, func );
+                                        makeMemberOp( dstParam, nullptr, field, func );
+                                }
+                        }
 …
+        }
+        Type * declToType( Declaration * decl ) {
+                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        return dwt->get_type();
+                }
+                return nullptr;
+        }
+        /// generates struct constructors, destructor, and assignment functions
+        void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
+        bool UnionFuncGenerator::shouldAutogen() const {
                 // Builtins do not use autogeneration.
+                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
+                // generate each of the functions based on the supplied FuncData objects
+                std::list< FunctionDecl * > newFuncs;
+                // structure that iterates aggregate decl members, returning their types
+                auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                for ( const FuncData & d : data ) {
+                        generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
+                }
+                return ! aggregateDecl->linkage.is_builtin;
+        }
+        // xxx - is this right?
+        bool UnionFuncGenerator::isConcurrentType() const { return false; };
+        /// generate a single union assignment expression (using memcpy)
+        template< typename OutputIterator >
+        void UnionFuncGenerator::makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->args.push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
+                copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+        /// generates the body of a union assignment/copy constructor/field constructor
+        void UnionFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) {
+                FunctionType * ftype = funcDecl->type;
+                if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) {
+                        assert( ftype->parameters.size() == 2 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() );
+                        makeMemberOp( srcParam, dstParam, back_inserter( funcDecl->statements->kids ) );
+                } else {
+                        // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
+                        assert( ftype->parameters.size() == 1 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        dstParam->attributes.push_back( new Attribute( "unused" ) );
+                }
+        }
+        /// generate the body of a constructor which takes parameters that match fields, e.g.
+        /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+        void UnionFuncGenerator::genFieldCtors() {
                 // field ctors are only generated if default constructor and copy constructor are both generated
+                unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
+                if ( functionNesting == 0 ) {
+                        // forward declare if top-level struct, so that
+                        // type is complete as soon as its body ends
+                        // Note: this is necessary if we want structs which contain
+                        // generic (otype) structs as members.
+                        for ( FunctionDecl * dcl : newFuncs ) {
+                                addForwardDecl( dcl, declsToAdd );
+                        }
+                }
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        // generate appropriate calls to member ctor, assignment
+                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                        if ( ! CodeGen::isDestructor( dcl->get_name() ) ) {
+                                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl );
+                        } else {
+                                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false );
+                        }
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->get_functionType();
+                                assert( assignType->get_parameters().size() == 2 );
+                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
+                                dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        }
+                        declsToAdd.push_back( dcl );
+                }
+                // create constructors which take each member type as a parameter.
+                // for example, for struct A { int x, y; }; generate
+                //   void ?{}(A *, int) and void ?{}(A *, int, int)
+                unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
                 // Field constructors are only generated if default and copy constructor
                 // are generated, since they need access to both
+                if ( numCtors == 2 ) {
+                        FunctionType * memCtorType = genDefaultType( refType );
+                        cloneAll( typeParams, memCtorType->get_forall() );
+                        for ( std::list<Declaration *>::iterator i = aggregateDecl->get_members().begin(); i != aggregateDecl->get_members().end(); ++i ) {
+                                DeclarationWithType * member = dynamic_cast<DeclarationWithType *>( *i );
+                                assert( member );
+                                if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( member ) ) ) {
+                                        // don't make a function whose parameter is an unnamed bitfield
+                                        continue;
+                                } else if ( member->get_name() == "" ) {
+                                        // don't assign to anonymous members
+                                        // xxx - this is a temporary fix. Anonymous members tie into
+                                        // our inheritance model. I think the correct way to handle this is to
+                                        // cast the structure to the type of the member and let the resolver
+                                        // figure out whether it's valid/choose the correct unnamed member
+                                        continue;
+                                }
+                                memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
+                                FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                                makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor );
+                                declsToAdd.push_back( ctor );
+                        }
+                        delete memCtorType;
+                }
+        }
+        /// generate a single union assignment expression (using memcpy)
+        template< typename OutputIterator >
+        void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+        /// generates the body of a union assignment/copy constructor/field constructor
+        void makeUnionAssignBody( FunctionDecl * funcDecl ) {
+                FunctionType * ftype = funcDecl->get_functionType();
+                assert( ftype->get_parameters().size() == 2 );
+                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
+                if ( CodeGen::isAssignment( funcDecl->get_name() ) ) {
+                        // also generate return statement in assignment
+                        funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                }
+        }
+        /// generates union constructors, destructors, and assignment operator
+        void makeUnionFunctions( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) {
+                // Make function polymorphic in same parameters as generic union, if applicable
+                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                // default ctor/dtor need only first parameter
+                // void ?{}(T *); void ^?{}(T *);
+                FunctionType *ctorType = genDefaultType( refType );
+                FunctionType *dtorType = genDefaultType( refType );
+                // copy ctor needs both parameters
+                // void ?{}(T *, T);
+                FunctionType *copyCtorType = genCopyType( refType );
+                // assignment needs both and return value
+                // T ?=?(T *, T);
+                FunctionType *assignType = genAssignType( refType );
+                cloneAll( typeParams, ctorType->get_forall() );
+                cloneAll( typeParams, dtorType->get_forall() );
+                cloneAll( typeParams, copyCtorType->get_forall() );
+                cloneAll( typeParams, assignType->get_forall() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting );
+                FunctionDecl *ctorDecl = genFunc( "?{}",  ctorType, functionNesting );
+                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting );
+                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
+                makeUnionAssignBody( assignDecl );
+                // body of assignment and copy ctor is the same
+                makeUnionAssignBody( copyCtorDecl );
+                if ( numCtors != 2 ) return;
                 // create a constructor which takes the first member type as a parameter.
 …
                 // void ?{}(A *, int)
                 // This is to mimic C's behaviour which initializes the first member of the union.
+                std::list<Declaration *> memCtors;
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
+                                ObjectDecl * srcParam = new ObjectDecl( "src", Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
+                                FunctionType * memCtorType = ctorType->clone();
+                                memCtorType->get_parameters().push_back( srcParam );
+                                FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting );
+                                makeUnionAssignBody( ctor );
+                                memCtors.push_back( ctor );
+                                // only generate a ctor for the first field
+                FunctionType * memCtorType = genDefaultType( type );
+                for ( Declaration * member : aggregateDecl->members ) {
+                        DeclarationWithType * field = strict_dynamic_cast<DeclarationWithType *>( member );
+                        if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) {
+                                // don't make a function whose parameter is an unnamed bitfield
                                 break;
+                        }
+                }
+                declsToAdd.push_back( ctorDecl );
+                declsToAdd.push_back( copyCtorDecl );
+                declsToAdd.push_back( dtorDecl );
+                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+                declsToAdd.splice( declsToAdd.end(), memCtors );
+        }
+                        memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, field->get_type()->clone(), nullptr ) );
+                        FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                        ObjectDecl * srcParam = strict_dynamic_cast<ObjectDecl *>( ctor->type->parameters.back() );
+                        srcParam->fixUniqueId();
+                        ObjectDecl * dstParam = InitTweak::getParamThis( ctor->type );
+                        makeMemberOp( srcParam, dstParam, back_inserter( ctor->statements->kids ) );
+                        resolve( ctor );
+                        // only generate one field ctor for unions
+                        break;
+                }
+                delete memCtorType;
+        }
+        void EnumFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) {
+                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
+                // Really they're something of a cross between instrinsic and autogen, so should
+                // probably make a new linkage type
+                funcDecl->linkage = LinkageSpec::Intrinsic;
+                FunctionType * ftype = funcDecl->type;
+                if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) {
+                        assert( ftype->parameters.size() == 2 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() );
+                        // enum copy construct and assignment is just C-style assignment.
+                        // this looks like a bad recursive call, but code gen will turn it into
+                        // a C-style assignment.
+                        // This happens before function pointer type conversion, so need to do it manually here
+                        ApplicationExpr * callExpr = new ApplicationExpr( VariableExpr::functionPointer( funcDecl ) );
+                        callExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                        callExpr->get_args().push_back( new VariableExpr( srcParam ) );
+                        funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) );
+                } else {
+                        // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
+                        assert( ftype->parameters.size() == 1 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        dstParam->attributes.push_back( new Attribute( "unused" ) );
+                }
+        }
+        bool EnumFuncGenerator::shouldAutogen() const { return true; }
+        bool EnumFuncGenerator::isConcurrentType() const { return false; }
+        // enums do not have field constructors
+        void EnumFuncGenerator::genFieldCtors() {}
+        bool TypeFuncGenerator::shouldAutogen() const { return true; };
+        void TypeFuncGenerator::genFuncBody( FunctionDecl * dcl ) {
+                FunctionType * ftype = dcl->type;
+                assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
+                DeclarationWithType * dst = ftype->parameters.front();
+                DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
+                // generate appropriate calls to member ctor, assignment
+                UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
+                expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
+                if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
+                dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+        };
+        // xxx - should reach in and determine if base type is concurrent?
+        bool TypeFuncGenerator::isConcurrentType() const { return false; };
+        // opaque types do not have field constructors
+        void TypeFuncGenerator::genFieldCtors() {};
+        //=============================================================================================
+        // Visitor definitions
+        //=============================================================================================
         AutogenerateRoutines::AutogenerateRoutines() {
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
                 data.emplace_back( "?{}", genDefaultType, constructable );
                 data.emplace_back( "?{}", genCopyType, copyable );
                 data.emplace_back( "^?{}", genDefaultType, destructable );
                 data.emplace_back( "?=?", genAssignType, assignable );
+                data.emplace_back( "?{}", genDefaultType );
+                data.emplace_back( "?{}", genCopyType );
+                data.emplace_back( "^?{}", genDefaultType );
+                data.emplace_back( "?=?", genAssignType );
+        }
         void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
+                visit_children = false;
+                if ( ! enumDecl->get_members().empty() ) {
+                        EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
+                        // enumInst->set_baseEnum( enumDecl );
+                        makeEnumFunctions( enumInst, functionNesting, declsToAddAfter );
+                // must visit children (enum constants) to add them to the indexer
+                if ( enumDecl->has_body() ) {
+                        EnumInstType enumInst( Type::Qualifiers(), enumDecl->get_name() );
+                        enumInst.set_baseEnum( enumDecl );
+                        EnumFuncGenerator gen( &enumInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
+                }
+        }
 …
         void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
                 visit_children = false;
                 if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
+                if ( structDecl->has_body() ) {
                         StructInstType structInst( Type::Qualifiers(), structDecl->name );
+                        structInst.set_baseStruct( structDecl );
                         for ( TypeDecl * typeDecl : structDecl->parameters ) {
-                                // need to visit assertions so that they are added to the appropriate maps
-                                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->name );
+                        StructFuncGenerator gen( structDecl, &structInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
                 } // if
+        }
 …
         void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
                 visit_children = false;
                 if ( ! unionDecl->get_members().empty() ) {
+                if ( unionDecl->has_body()  ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
                         unionInst.set_baseUnion( unionDecl );
 …
                                 unionInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                        }
+                        makeUnionFunctions( unionDecl, &unionInst, functionNesting, declsToAddAfter );
+                        UnionFuncGenerator gen( unionDecl, &unionInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
                 } // if
+        }
-        Type * declToTypeDeclBase( Declaration * decl ) {
-                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
-                        return td->base;
+                }
-                return nullptr;
+        }
 …
                 if ( ! typeDecl->base ) return;
-                // generate each of the functions based on the supplied FuncData objects
-                std::list< FunctionDecl * > newFuncs;
-                std::list< Declaration * > tds { typeDecl };
-                std::list< TypeDecl * > typeParams;
                 TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl );
+                auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                for ( const FuncData & d : data ) {
+                        generator.gen( d, false );
+                }
+                if ( functionNesting == 0 ) {
+                        // forward declare if top-level struct, so that
+                        // type is complete as soon as its body ends
+                        // Note: this is necessary if we want structs which contain
+                        // generic (otype) structs as members.
+                        for ( FunctionDecl * dcl : newFuncs ) {
+                                addForwardDecl( dcl, declsToAddAfter );
+                        }
+                }
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        FunctionType * ftype = dcl->type;
+                        assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
+                        DeclarationWithType * dst = ftype->parameters.front();
+                        DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
+                        // generate appropriate calls to member ctor, assignment
+                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                        UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
+                        expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
+                        if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
+                        dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->type;
+                                assert( assignType->parameters.size() == 2 );
+                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() );
+                                dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        }
+                        declsToAddAfter.push_back( dcl );
+                }
+                TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer );
+                generateFunctions( gen, declsToAddAfter );
+        }
 …
                 visit_children = false;
                 // record the existence of this function as appropriate
+                insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
+                insert( functionDecl, assignable, InitTweak::isAssignment );
+                insert( functionDecl, copyable, InitTweak::isCopyConstructor );
+                insert( functionDecl, destructable, InitTweak::isDestructor );
+                managedTypes.handleDWT( functionDecl );
                 maybeAccept( functionDecl->type, *visitor );
 …
         void AutogenerateRoutines::previsit( CompoundStmt * ) {
+                GuardScope( constructable );
+                GuardScope( assignable );
+                GuardScope( copyable );
+                GuardScope( destructable );
+                GuardScope( managedTypes );
                 GuardScope( structsDone );
+        }

src/SymTab/Autogen.h

-              rb96ec83
+              r6840e7c
 #include <string>                 // for string
+#include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
 #include "InitTweak/InitTweak.h"  // for InitExpander
 …
         // generate the type of a copy constructor for paramType
         FunctionType * genDefaultType( Type * paramType );
+        FunctionType * genCopyType( Type * paramType );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
 …
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new AddressExpr( dstParam );
+                        addCast = false;
+                        isReferenceCtorDtor = true;
+                }
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
                 UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
                 if ( addCast ) {
 …
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
+                }
                 fExpr->get_args().push_back( dstParam );
+                fExpr->args.push_back( dstParam );
                 Statement * listInit = srcParam.buildListInit( fExpr );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
+                // fetch next set of arguments
+                ++srcParam;
+                // return if adding reference fails - will happen on default constructor and destructor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
+                        delete fExpr;
+                        return listInit;
+                }
+                std::list< Expression * > args = *srcParam;
+                fExpr->args.splice( fExpr->args.end(), args );
                 *out++ = new ExprStmt( noLabels, fExpr );
 …
                         // generate: for ( int i = 0; i < N; ++i )
                         begin = new ConstantExpr( Constant::from_int( 0 ) );
                         end = array->get_dimension()->clone();
+                        end = array->dimension->clone();
                         cmp = new NameExpr( "?<?" );
                         update = new NameExpr( "++?" );
 …
                         // generate: for ( int i = N-1; i >= 0; --i )
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
                         ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
                         ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
+                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
                         end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
 …
                 UntypedExpr *cond = new UntypedExpr( cmp );
                 cond->get_args().push_back( new VariableExpr( index ) );
                 cond->get_args().push_back( end );
+                cond->args.push_back( new VariableExpr( index ) );
+                cond->args.push_back( end );
                 UntypedExpr *inc = new UntypedExpr( update );
                 inc->get_args().push_back( new VariableExpr( index ) );
+                inc->args.push_back( new VariableExpr( index ) );
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
                 dstIndex->get_args().push_back( dstParam );
                 dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstIndex->args.push_back( dstParam );
+                dstIndex->args.push_back( new VariableExpr( index ) );
                 dstParam = dstIndex;
                 // srcParam must keep track of the array indices to build the
                 // source parameter and/or array list initializer
                 srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
                 Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
                 // block containing for stmt and index variable
                 std::list<Statement *> initList;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                block->push_back( new DeclStmt( noLabels, index ) );
                 if ( listInit ) block->get_kids().push_back( listInit );
                 block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
                 *out++ = block;
 …
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
 …
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
         void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
 …
                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
                 // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call

src/SymTab/FixFunction.cc

-              rb96ec83
+              r6840e7c
         FixFunction::FixFunction() : isVoid( false ) {}
+        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+        DeclarationWithType * FixFunction::postmutate(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();
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
+                functionDecl->attributes.clear();
                 functionDecl->type = nullptr;
                 delete functionDecl;
 …
+        }
+        Type * FixFunction::mutate(VoidType *voidType) {
+                isVoid = true;
+                return voidType;
+        }
+        Type * FixFunction::mutate(BasicType *basicType) {
+                return basicType;
+        }
+        Type * FixFunction::mutate(PointerType *pointerType) {
+                return pointerType;
+        }
+        Type * FixFunction::mutate(ArrayType *arrayType) {
+        Type * FixFunction::postmutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
+                arrayType->base = nullptr;
+                arrayType->dimension = nullptr;
                 delete arrayType;
                 return pointerType;
+        }
         Type * FixFunction::mutate(StructInstType *aggregateUseType) {
                 return aggregateUseType;
+        void FixFunction::premutate(VoidType *) {
+                isVoid = true;
+        }
+        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TraitInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TupleType *tupleType) {
+                return tupleType;
+        }
+        Type * FixFunction::mutate(VarArgsType *varArgsType) {
+                return varArgsType;
+        }
+        Type * FixFunction::mutate(ZeroType *zeroType) {
+                return zeroType;
+        }
+        Type * FixFunction::mutate(OneType *oneType) {
+                return oneType;
+        }
+        void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
+        void FixFunction::premutate(BasicType *) { visit_children = false; }
+        void FixFunction::premutate(PointerType *) { visit_children = false; }
+        void FixFunction::premutate(StructInstType *) { visit_children = false; }
+        void FixFunction::premutate(UnionInstType *) { visit_children = false; }
+        void FixFunction::premutate(EnumInstType *) { visit_children = false; }
+        void FixFunction::premutate(TraitInstType *) { visit_children = false; }
+        void FixFunction::premutate(TypeInstType *) { visit_children = false; }
+        void FixFunction::premutate(TupleType *) { visit_children = false; }
+        void FixFunction::premutate(VarArgsType *) { visit_children = false; }
+        void FixFunction::premutate(ZeroType *) { visit_children = false; }
+        void FixFunction::premutate(OneType *) { visit_children = false; }
 } // namespace SymTab

src/SymTab/FixFunction.h

-              rb96ec83
+              r6840e7c
 #pragma once
 #include "SynTree/Mutator.h"  // for Mutator
 #include "SynTree/SynTree.h"  // for Types
+#include "Common/PassVisitor.h" // for PassVisitor
+#include "SynTree/SynTree.h"    // for Types
 namespace SymTab {
         /// Replaces function and array types by equivalent pointer types.
         class FixFunction : public Mutator {
+        class FixFunction : public WithShortCircuiting {
                 typedef Mutator Parent;
           public:
                 FixFunction();
+                bool get_isVoid() const { return isVoid; }
+                void set_isVoid( bool newValue ) { isVoid = newValue; }
+          private:
+                virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
+                void premutate(FunctionDecl *functionDecl);
+                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
+                virtual Type* mutate(VoidType *voidType);
+                virtual Type* mutate(BasicType *basicType);
+                virtual Type* mutate(PointerType *pointerType);
+                virtual Type* mutate(ArrayType *arrayType);
+                virtual Type* mutate(StructInstType *aggregateUseType);
+                virtual Type* mutate(UnionInstType *aggregateUseType);
+                virtual Type* mutate(EnumInstType *aggregateUseType);
+                virtual Type* mutate(TraitInstType *aggregateUseType);
+                virtual Type* mutate(TypeInstType *aggregateUseType);
+                virtual Type* mutate(TupleType *tupleType);
+                virtual Type* mutate(VarArgsType *varArgsType);
+                virtual Type* mutate(ZeroType *zeroType);
+                virtual Type* mutate(OneType *oneType);
+                Type * postmutate(ArrayType * arrayType);
+                void premutate(VoidType * voidType);
+                void premutate(BasicType * basicType);
+                void premutate(PointerType * pointerType);
+                void premutate(StructInstType * aggregateUseType);
+                void premutate(UnionInstType * aggregateUseType);
+                void premutate(EnumInstType * aggregateUseType);
+                void premutate(TraitInstType * aggregateUseType);
+                void premutate(TypeInstType * aggregateUseType);
+                void premutate(TupleType * tupleType);
+                void premutate(VarArgsType * varArgsType);
+                void premutate(ZeroType * zeroType);
+                void premutate(OneType * oneType);
                 bool isVoid;

src/SymTab/Indexer.cc

-              rb96ec83
+              r6840e7c
                 makeWritable();
                 const std::string &name = decl->get_name();
+                const std::string &name = decl->name;
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( decl->linkage ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines are placed into the
                         // same "bucket" as their user defined versions.
 …
                 // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
                 if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) {
+                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
                         // NOTE this is broken in Richard's original code in such a way that it never triggers (it
                         // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
 …
                 if ( doDebug ) {
                         std::cout << "--- Entering scope " << scope << std::endl;
+                        std::cerr << "--- Entering scope " << scope << std::endl;
+                }
+        }
         void Indexer::leaveScope() {
                 using std::cout;
+                using std::cerr;
                 assert( scope > 0 && "cannot leave initial scope" );
+                if ( doDebug ) {
+                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
+                }
                 --scope;
                 while ( tables && tables->scope > scope ) {
                         if ( doDebug ) {
+                                cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
+                                dump( tables->idTable, cout );
+                                dump( tables->typeTable, cout );
+                                dump( tables->structTable, cout );
+                                dump( tables->enumTable, cout );
+                                dump( tables->unionTable, cout );
+                                dump( tables->traitTable, cout );
+                                dump( tables->idTable, cerr );
+                                dump( tables->typeTable, cerr );
+                                dump( tables->structTable, cerr );
+                                dump( tables->enumTable, cerr );
+                                dump( tables->unionTable, cerr );
+                                dump( tables->traitTable, cerr );
+                        }

src/SymTab/Mangler.cc

-              rb96ec83
+              r6840e7c
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jun 28 15:31:00 2017
 // Update Count     : 21
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 15:49:26 2017
+// Update Count     : 23
 //
 #include "Mangler.h"
 …
                         "Id",   // DoubleImaginary
                         "Ir",   // LongDoubleImaginary
+                        "w",    // SignedInt128
+                        "Uw",   // UnsignedInt128
                 };

src/SymTab/Validate.cc

-              rb96ec83
+              r6840e7c
                 void previsit( ObjectDecl * object );
                 void previsit( FunctionDecl * func );
+                void previsit( StructDecl * aggrDecl );
+                void previsit( UnionDecl * aggrDecl );
         };
 …
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                ReturnChecker::checkFunctionReturns( translationUnit );
+                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
                 Concurrency::applyKeywords( translationUnit );
+                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
-                ReturnChecker::checkFunctionReturns( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
-                acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
                 acceptAll( translationUnit, finder );
+                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
                 mutateAll( translationUnit, labelAddrFixer );
+        }
 …
                         DWTIterator begin( dwts.begin() ), end( dwts.end() );
                         if ( begin == end ) return;
                         FixFunction fixer;
+                        PassVisitor<FixFunction> fixer;
                         DWTIterator i = begin;
                         *i = (*i)->acceptMutator( fixer );
                         if ( fixer.get_isVoid() ) {
+                        if ( fixer.pass.isVoid ) {
                                 DWTIterator j = i;
                                 ++i;
 …
                                 ++i;
                                 for ( ; i != end; ++i ) {
                                         FixFunction fixer;
+                                        PassVisitor<FixFunction> fixer;
                                         *i = (*i)->acceptMutator( fixer );
                                         if ( fixer.get_isVoid() ) {
+                                        if ( fixer.pass.isVoid ) {
                                                 throw SemanticError( "invalid type void in function type ", func );
                                         } // if
 …
                         // apply FixFunction to every assertion to check for invalid void type
                         for ( DeclarationWithType *& assertion : type->assertions ) {
                                 FixFunction fixer;
+                                PassVisitor<FixFunction> fixer;
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.get_isVoid() ) {
+                                if ( fixer.pass.isVoid ) {
                                         throw SemanticError( "invalid type void in assertion of function ", node );
                                 } // if
 …
                 forallFixer( func->type->forall, func );
                 func->fixUniqueId();
+        }
+        void ForallPointerDecay::previsit( StructDecl * aggrDecl ) {
+                forallFixer( aggrDecl->parameters, aggrDecl );
+        }
+        void ForallPointerDecay::previsit( UnionDecl * aggrDecl ) {
+                forallFixer( aggrDecl->parameters, aggrDecl );
+        }

src/SynTree/AddressExpr.cc

-              rb96ec83
+              r6840e7c
         Type * addrType( Type * type ) {
                 if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
                         return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
                 } else {
                         return new PointerType( Type::Qualifiers(), type->clone() );
 …
+}
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
                 if ( arg->get_result()->get_lvalue() ) {
+AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
+        if ( arg->result ) {
+                if ( arg->result->get_lvalue() ) {
                         // lvalue, retains all layers of reference and gains a pointer inside the references
                         set_result( addrType( arg->get_result() ) );
+                        set_result( addrType( arg->result ) );
                 } else {
                         // taking address of non-lvalue -- must be a reference, loses one layer of reference
                         ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
                         set_result( addrType( refType->get_base() ) );
+                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
+                        set_result( addrType( refType->base ) );
+                }
                 // result of & is never an lvalue
 …
+}
 void AddressExpr::print( std::ostream &os, int indent ) const {
+void AddressExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Address of:" << std::endl;
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
                 arg->print( os, indent+2 );
+                os << indent+1;
+                arg->print( os, indent+1 );
         } // if
+}
 …
 LabelAddressExpr::~LabelAddressExpr() {}
 void LabelAddressExpr::print( std::ostream & os, int indent ) const {
         os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg;
+void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
+        os << "Address of label:" << arg;
+}

src/SynTree/AggregateDecl.cc

-              rb96ec83
+              r6840e7c
+}
 void AggregateDecl::print( std::ostream &os, int indent ) const {
+void AggregateDecl::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
         os << typeString() << " " << get_name() << ":";
+        os << typeString() << " " << name << ":";
         if ( get_linkage() != LinkageSpec::Cforall ) {
                 os << " " << LinkageSpec::linkageName( get_linkage() );
+                os << " " << LinkageSpec::linkageName( linkage );
         } // if
         os << " with body " << has_body() << endl;
+        os << " with body " << has_body();
         if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! members.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with members" << endl;
                 printAll( members, os, indent+4 );
+                os << endl << indent << "... with members" << endl;
+                printAll( members, os, indent+1 );
         } // if
         if ( ! attributes.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
                 printAll( attributes, os, indent+4 );
+                os << endl << indent << "... with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if
+        os << endl;
+}
 void AggregateDecl::printShort( std::ostream &os, int indent ) const {
+void AggregateDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
+        os << typeString() << " " << get_name();
+        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
+        os << typeString() << " " << name << " with body " << has_body() << endl;
         if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ApplicationExpr.cc

-              rb96ec83
+              r6840e7c
         set_result( ResolvExpr::extractResultType( function ) );
         assert( has_result() );
+        assert( result );
+}
 …
+}
 void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
                 os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl;
+                os << indent << "with inferred parameters " << level << ":" << std::endl;
                 for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
                         os << std::string(indent+2, ' ');
                         Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
+                        os << indent+1;
+                        Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
                         os << std::endl;
                         printInferParams( *i->second.inferParams, os, indent+2, level+1 );
+                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
                 } // for
         } // if
+}
+void ApplicationExpr::print( std::ostream &os, int indent ) const {
+        os << "Application of" << std::endl << std::string(indent+2, ' ');
+        function->print( os, indent+2 );
+void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Application of" << std::endl << indent+1;
+        function->print( os, indent+1 );
+        os << std::endl;
         if ( ! args.empty() ) {
                 os << std::string( indent, ' ' ) << "to arguments" << std::endl;
                 printAll( args, os, indent+2 );
+                os << indent << "... to arguments" << std::endl;
+                printAll( args, os, indent+1 );
         } // if
         printInferParams( inferParams, os, indent+2, 0 );
+        printInferParams( inferParams, os, indent+1, 0 );
         Expression::print( os, indent );
+}

src/SynTree/ArrayType.cc

rb96ec83	r6840e7c
39	39	}
40	40
41		void ArrayType::print( std::ostream &os, ~~int~~ indent ) const {
	41	void ArrayType::print( std::ostream &os, Indenter indent ) const {
42	42	Type::print( os, indent );
43	43	if ( isStatic ) {

src/SynTree/AttrType.cc

-              rb96ec83
+              r6840e7c
 // file "LICENCE" distributed with Cforall.
 //
 // AttrType.cc.cc --
+// AttrType.cc.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void AttrType::print( std::ostream &os, int indent ) const {
+void AttrType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "attribute " << name << " applied to ";

src/SynTree/Attribute.cc

rb96ec83	r6840e7c
28	28	}
29	29
30		void Attribute::print( std::ostream &os, ~~int~~ indent ) const {
	30	void Attribute::print( std::ostream &os, Indenter indent ) const {
31	31	using std::endl;
32	32	using std::string;
…	…
36	36	if ( ! parameters.empty() ) {
37	37	os << " with parameters: " << endl;
38		printAll( parameters, os, indent );
	38	printAll( parameters, os, indent+1 );
39	39	}
40	40	}

src/SynTree/Attribute.h

-              rb96ec83
+              r6840e7c
         bool empty() const { return name == ""; }
         Attribute * clone() const { return new Attribute( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Attribute * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        Attribute * clone() const override { return new Attribute( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/SynTree/BaseSyntaxNode.h

-              rb96ec83
+              r6840e7c
 #include "Common/CodeLocation.h"
+#include "Common/Indenter.h"
 class Visitor;
 class Mutator;
 …
         virtual void accept( Visitor & v ) = 0;
         virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
+  /// Notes:
+  /// * each node is responsible for indenting its children.
+  /// * Expressions should not finish with a newline, since the expression's parent has better information.
+        virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
+  void print( std::ostream & os, unsigned int indent ) {
+    print( os, Indenter{ Indenter::tabsize, indent });
+  }
 };

src/SynTree/BasicType.cc

-              rb96ec83
+              r6840e7c
 // file "LICENCE" distributed with Cforall.
 //
 // BasicType.cc --
+// BasicType.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 11 12:52:05 2017
 // Update Count     : 9
+// Last Modified On : Mon Sep 25 14:14:03 2017
+// Update Count     : 11
 //
 …
 BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
 void BasicType::print( std::ostream &os, int indent ) const {
+void BasicType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << BasicType::typeNames[ kind ];
 …
           case LongLongSignedInt:
           case LongLongUnsignedInt:
+          case SignedInt128:
+          case UnsignedInt128:
                 return true;
           case Float:

src/SynTree/CommaExpr.cc

-              rb96ec83
+              r6840e7c
 #include "Type.h"            // for Type
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
                 : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
+CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
+                : Expression(), arg1( arg1 ), arg2( arg2 ) {
         // xxx - result of a comma expression is never an lvalue, so should set lvalue
         // to false on all result types. Actually doing this causes some strange things
 …
+}
 void CommaExpr::print( std::ostream &os, int indent ) const {
+void CommaExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Comma Expression:" << std::endl;
         os << std::string( indent+2, ' ' );
         arg1->print( os, indent+2 );
+        os << (indent+1);
+        arg1->print( os, indent+1 );
         os << std::endl;
         os << std::string( indent+2, ' ' );
         arg2->print( os, indent+2 );
+        os << (indent+1);
+        arg2->print( os, indent+1 );
         Expression::print( os, indent );
+}

src/SynTree/CompoundStmt.cc

rb96ec83	r6840e7c
73	73	}
74	74
75		void CompoundStmt::print( std::ostream &os, ~~int~~ indent ) const {
76		os << "CompoundStmt" << endl ;
77		printAll( kids, os, indent ~~+ 2~~ );
	75	void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
	76	os << "CompoundStmt" << endl;
	77	printAll( kids, os, indent+1 );
78	78	}
79	79

src/SynTree/Constant.cc

rb96ec83	r6840e7c
71	71	}
72	72
73		void Constant::print( std::ostream &os ) const {
	73	void Constant::print( std::ostream &os, Indenter ) const {
74	74	os << "(" << rep << " " << val.ival;
75	75	if ( type ) {

src/SynTree/Constant.h

-              rb96ec83
+              r6840e7c
 #include <string>     // for string
+#include "BaseSyntaxNode.h"
 #include "Mutator.h"  // for Mutator
 #include "Visitor.h"  // for Visitor
 …
 class Type;
 class Constant {
+class Constant : public BaseSyntaxNode {
   public:
         Constant( Type * type, std::string rep, unsigned long long val );
 …
         Constant( const Constant & other );
         virtual ~Constant();
+        virtual Constant * clone() const { return new Constant( *this ); }
         Type * get_type() { return type; }
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os ) const;
+        virtual void print( std::ostream & os, Indenter indent = 0 ) const;
   private:
         Type * type;

src/SynTree/DeclStmt.cc

rb96ec83	r6840e7c
33	33	}
34	34
35		void DeclStmt::print( std::ostream &os, ~~int~~ indent ) const {
	35	void DeclStmt::print( std::ostream &os, Indenter indent ) const {
36	36	assert( decl != 0 );
37	37	os << "Declaration of ";

src/SynTree/Declaration.cc

-              rb96ec83
+              r6840e7c
 void Declaration::fixUniqueId() {
+        // don't need to set unique ID twice
+        if ( uniqueId ) return;
         uniqueId = ++lastUniqueId;
         idMap[ uniqueId ] = this;
 …
+}
 void AsmDecl::print( std::ostream &os, int indent ) const {
+void AsmDecl::print( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
+}
 void AsmDecl::printShort( std::ostream &os, int indent ) const {
+void AsmDecl::printShort( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
+}

src/SynTree/Declaration.h

-              rb96ec83
+              r6840e7c
         void fixUniqueId( void );
         virtual Declaration *clone() const = 0;
+        virtual Declaration *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
         virtual Declaration *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
         virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
+        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
         static void dumpIds( std::ostream &os );
 …
         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 void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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 void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
 …
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
         virtual void print( std::ostream &os, int indent = 0 ) const override;
         virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
   protected:
         virtual std::string typeString() const = 0;
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };

src/SynTree/Expression.cc

-              rb96ec83
+              r6840e7c
 #include "GenPoly/Lvalue.h"
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
 Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression() : result( 0 ), env( 0 ) {}
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ) {
+}
 Expression::~Expression() {
         delete env;
-        delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
         delete result;
+}
 void Expression::print( std::ostream &os, int indent ) const {
+void Expression::print( std::ostream &os, Indenter indent ) const {
         if ( env ) {
                 os << std::string( indent, ' ' ) << "with environment:" << std::endl;
                 env->print( os, indent+2 );
+                os << std::endl << indent << "... with environment:" << std::endl;
+                env->print( os, indent+1 );
         } // if
+        if ( argName ) {
+                os << std::string( indent, ' ' ) << "with designator:";
+                argName->print( os, indent+2 );
+        if ( extension ) {
+                os << std::endl << indent << "... with extension:";
         } // if
+        if ( extension ) {
+                os << std::string( indent, ' ' ) << "with extension:";
+        } // if
+}
+ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
+}
+ConstantExpr::ConstantExpr( Constant _c ) : Expression(), constant( _c ) {
         set_result( constant.get_type()->clone() );
+}
 …
 ConstantExpr::~ConstantExpr() {}
 void ConstantExpr::print( std::ostream &os, int indent ) const {
+void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
 …
+}
 VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
+VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
         assert( var );
         assert( var->get_type() );
 …
+}
 void VariableExpr::print( std::ostream &os, int indent ) const {
+void VariableExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Variable Expression: ";
+        Declaration *decl = get_var();
+        if ( decl != 0) decl->printShort(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        var->printShort(os, indent);
+        Expression::print( os, indent );
+}
+SizeofExpr::SizeofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
+SizeofExpr::SizeofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
 void SizeofExpr::print( std::ostream &os, int indent) const {
+void SizeofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Sizeof Expression on: ";
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+AlignofExpr::AlignofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
+AlignofExpr::AlignofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
 void AlignofExpr::print( std::ostream &os, int indent) const {
+void AlignofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Alignof Expression on: ";
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
+                Expression( _aname ), type(type_), member(member_) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+                Expression(), type(type), member(member) {
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
+void UntypedOffsetofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Untyped Offsetof Expression on member " << member << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
+                Expression( _aname ), type(type_), member(member_) {
+void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Untyped Offsetof Expression on member " << member << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+                Expression(), type(type), member(member) {
+        assert( member );
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
+void OffsetofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Offsetof Expression on member ";
+        if ( member ) {
+                os << member->get_name();
+        } else {
+                os << "<NULL>";
+        }
+        os << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Offsetof Expression on member " << member->name << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+        assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
 …
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
+void OffsetPackExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Offset pack expression on ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {
+}
+AttrExpr::AttrExpr( Expression *attr, Type *type_, Expression *_aname ) :
+                Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true) {
+void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Offset pack expression on ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
+                Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
+}
+AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
+                Expression(), attr( attr ), expr(0), type(type_), isType(true) {
+}
 …
+}
 void AttrExpr::print( std::ostream &os, int indent) const {
+void AttrExpr::print( std::ostream &os, Indenter indent) const {
         os << "Attr ";
         attr->print( os, indent + 2 );
+        attr->print( os, indent+1);
         if ( isType || expr ) {
                 os << "applied to: ";
+                if (isType)
+                        type->print(os, indent + 2);
+                else
+                        expr->print(os, indent + 2);
+                if (isType) type->print(os, indent+1);
+                else expr->print(os, indent+1);
         } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        Expression::print( os, indent );
+}
+CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
+}
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
         set_result( new VoidType( Type::Qualifiers() ) );
+}
 …
+}
+void CastExpr::print( std::ostream &os, int indent ) const {
+        os << "Cast of:" << std::endl << std::string( indent+2, ' ' );
+        arg->print(os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
+        os << std::string( indent+2, ' ' );
+void CastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( result->isVoid() ) {
                 os << "nothing";
+                os << " nothing";
         } else {
+                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
-        os << std::endl;
         Expression::print( os, indent );
+}
 …
+}
+void VirtualCastExpr::print( std::ostream &os, int indent ) const {
+        os << "Virtual Cast of:" << std::endl << std::string( indent+2, ' ' );
+        arg->print(os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
+        os << std::string( indent+2, ' ' );
+void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Virtual Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( ! result ) {
                 os << "unknown";
+                os << " unknown";
         } else {
+                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+                Expression( _aname ), member(_member), aggregate(_aggregate) {}
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( aggregate );
+}
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
 …
+}
+void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
+        os << "Untyped Member Expression, with field: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        get_member()->print(os, indent+4);
+        os << std::string( indent+2, ' ' );
+        Expression *agg = get_aggregate();
+        os << "from aggregate: " << std::endl;
+        if (agg != 0) {
+                os << std::string( indent + 4, ' ' );
+                agg->print(os, indent + 4);
+        }
+        os << std::string( indent+2, ' ' );
+void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Untyped Member Expression, with field: " << std::endl << indent+1;
+        member->print(os, indent+1 );
+        os << indent << "... from aggregate: " << std::endl << indent+1;
+        aggregate->print(os, indent+1);
         Expression::print( os, indent );
+}
 …
+MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
+                Expression( _aname ), member(_member), aggregate(_aggregate) {
+MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( member );
+        assert( aggregate );
         TypeSubstitution sub( makeSub( aggregate->get_result() ) );
 …
+}
 void MemberExpr::print( std::ostream &os, int indent ) const {
+void MemberExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Member Expression, with field: " << std::endl;
+        assert( member );
+        os << std::string( indent + 2, ' ' );
+        member->print( os, indent + 2 );
+        os << std::endl;
+        Expression *agg = get_aggregate();
+        os << std::string( indent, ' ' ) << "from aggregate: " << std::endl;
+        if (agg != 0) {
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
+        }
+        os << std::string( indent+2, ' ' );
+        Expression::print( os, indent );
+}
+UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
+        os << indent+1;
+        member->print( os, indent+1 );
+        os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
+        aggregate->print(os, indent + 1);
+        Expression::print( os, indent );
+}
+UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+                Expression(), function(function), args(args) {}
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
 …
 void UntypedExpr::print( std::ostream &os, int indent ) const {
+void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Applying untyped: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        function->print(os, indent + 2);
+        os << std::string( indent, ' ' ) << "...to: " << std::endl;
+        printAll(args, os, indent + 2);
+        Expression::print( os, indent );
+}
+void UntypedExpr::printArgs( std::ostream &os, int indent ) const {
+        std::list<Expression *>::const_iterator i;
+        for (i = args.begin(); i != args.end(); i++) {
+                os << std::string(indent, ' ' );
+                (*i)->print(os, indent);
+        }
+}
+NameExpr::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {
+        assertf(_name != "0", "Zero is not a valid name\n");
+        assertf(_name != "1", "One is not a valid name\n");
+        os << indent+1;
+        function->print(os, indent+1);
+        os << std::endl << indent << "...to: " << std::endl;
+        printAll(args, os, indent+1);
+        Expression::print( os, indent );
+}
+NameExpr::NameExpr( std::string name ) : Expression(), name(name) {
+        assertf(name != "0", "Zero is not a valid name");
+        assertf(name != "1", "One is not a valid name");
+}
 …
 NameExpr::~NameExpr() {}
 void NameExpr::print( std::ostream &os, int indent ) const {
         os << "Name: " << get_name() << std::endl;
         Expression::print( os, indent );
+}
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
+void NameExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Name: " << get_name();
+        Expression::print( os, indent );
+}
+LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+                Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
 …
+}
 void LogicalExpr::print( std::ostream &os, int indent )const {
         os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+        os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
         os << " and ";
         arg2->print(os);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
+                Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
+        Expression::print( os, indent );
+}
+ConditionalExpr::ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 ) :
+                Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
 …
+}
+void ConditionalExpr::print( std::ostream &os, int indent ) const {
+        os << "Conditional expression on: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg1->print( os, indent+2 );
+        os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg2->print( os, indent+2 );
+        os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg3->print( os, indent+2 );
+        os << std::endl;
+void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Conditional expression on: " << std::endl << indent+1;
+        arg1->print( os, indent+1 );
+        os << indent << "First alternative:" << std::endl << indent+1;
+        arg2->print( os, indent+1 );
+        os << indent << "Second alternative:" << std::endl << indent+1;
+        arg3->print( os, indent+1 );
         Expression::print( os, indent );
+}
 …
 void AsmExpr::print( std::ostream &os, int indent ) const {
+void AsmExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent + 2 );
         if ( constraint ) constraint->print( os, indent + 2 );
         if ( operand ) operand->print( os, indent + 2 );
+        if ( inout ) inout->print( os, indent+1 );
+        if ( constraint ) constraint->print( os, indent+1 );
+        if ( operand ) operand->print( os, indent+1 );
+}
 …
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
         assert( callExpr->has_result() );
+        assert( callExpr->result );
         set_result( callExpr->get_result()->clone() );
+}
 …
+}
+void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Implicit Copy Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+        callExpr->print( os, indent + 2 );
+        os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
+        printAll(tempDecls, os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "with return temporaries:" << std::endl;
+        printAll(returnDecls, os, indent+2);
+void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+        os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
+        callExpr->print( os, indent+1 );
+        os << std::endl << indent << "... with temporaries:" << std::endl;
+        printAll( tempDecls, os, indent+1 );
+        os << std::endl << indent << "... with return temporaries:" << std::endl;
+        printAll( returnDecls, os, indent+1 );
         Expression::print( os, indent );
+}
 …
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
         set_result( maybeClone( arg->get_result() ) );
+        set_result( maybeClone( arg->result ) );
+}
 …
+}
+void ConstructorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+        os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
         Expression::print( os, indent );
 …
+}
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        get_result()->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        initializer->print( os, indent + 2 );
+void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound Literal Expression: " << std::endl << indent+1;
+        result->print( os, indent+1 );
+        os << indent+1;
+        initializer->print( os, indent+1 );
         Expression::print( os, indent );
+}
 …
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
 RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
+void RangeExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
 …
         deleteAll( returnDecls );
+}
 void StmtExpr::print( std::ostream &os, int indent ) const {
         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
         statements->print( os, indent+2 );
+void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Statement Expression: " << std::endl << indent+1;
+        statements->print( os, indent+1 );
         if ( ! returnDecls.empty() ) {
                 os << std::string( indent+2, ' ' ) << "with returnDecls: ";
                 printAll( returnDecls, os, indent+2 );
+                os << indent+1 << "... with returnDecls: ";
+                printAll( returnDecls, os, indent+1 );
+        }
         if ( ! dtors.empty() ) {
                 os << std::string( indent+2, ' ' ) << "with dtors: ";
                 printAll( dtors, os, indent+2 );
+                os << indent+1 << "... with dtors: ";
+                printAll( dtors, os, indent+1 );
+        }
         Expression::print( os, indent );
 …
         delete var;
+}
 void UniqueExpr::print( std::ostream &os, int indent ) const {
         os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
         get_expr()->print( os, indent+2 );
         if ( get_object() ) {
                 os << std::string( indent+2, ' ' ) << "with decl: ";
                 get_object()->printShort( os, indent+2 );
+void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Unique Expression with id:" << id << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        if ( object ) {
+                os << indent << "... with decl: ";
+                get_object()->printShort( os, indent+1 );
+        }
         Expression::print( os, indent );
 …
+}
 void UntypedInitExpr::print( std::ostream & os, int indent ) const {
         os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
         expr->print( os, indent+2 );
+void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Untyped Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
         if ( ! initAlts.empty() ) {
                 for ( const InitAlternative & alt : initAlts ) {
                         os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
                         alt.type->print( os, indent+2 );
                         alt.designation->print( os, indent+2 );
+                        os << indent+1 <<  "InitAlternative: ";
+                        alt.type->print( os, indent+1 );
+                        alt.designation->print( os, indent+1 );
+                }
+        }
 …
+}
 void InitExpr::print( std::ostream & os, int indent ) const {
         os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
         expr->print( os, indent+2 );
         os << std::string( indent+2, ' ' ) << "with designation: ";
         designation->print( os, indent+2 );
+void InitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        os << indent+1 << "... with designation: ";
+        designation->print( os, indent+1 );
+}

src/SynTree/Expression.h

-              rb96ec83
+              r6840e7c
         Type * result;
         TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
         bool extension = false;
         Expression( Expression * _aname = nullptr );
+        Expression();
         Expression( const Expression & other );
         virtual ~Expression();
 …
         const Type * get_result() const { return result; }
         void set_result( Type * newValue ) { result = newValue; }
-        bool has_result() const { return result != nullptr; }
         TypeSubstitution * get_env() const { return env; }
         void set_env( TypeSubstitution * newValue ) { env = newValue; }
-        Expression * get_argName() const { return argName; }
-        void set_argName( Expression * name ) { argName = name; }
         bool get_extension() const { return extension; }
         Expression * set_extension( bool exten ) { extension = exten; return this; }
         virtual Expression * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual Expression * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual Expression * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Expression * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> args;
         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
+        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
         UntypedExpr( const UntypedExpr & other );
         virtual ~UntypedExpr();
 …
         void set_function( Expression * newValue ) { function = newValue; }
-        void set_args( std::list<Expression *> & listArgs ) { args = listArgs; }
         std::list<Expression*>::iterator begin_args() { return args.begin(); }
         std::list<Expression*>::iterator end_args() { return args.end(); }
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void printArgs(std::ostream & os, int indent = 0) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::string name;
         NameExpr( std::string name, Expression *_aname = nullptr );
+        NameExpr( std::string name );
         NameExpr( const NameExpr & other );
         virtual ~NameExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg;
         AddressExpr( Expression * arg, Expression *_aname = nullptr );
+        AddressExpr( Expression * arg );
         AddressExpr( const AddressExpr & other );
         virtual ~AddressExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg;
         CastExpr( Expression * arg, Expression *_aname = nullptr );
         CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
+        CastExpr( Expression * arg );
+        CastExpr( Expression * arg, Type * toType );
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * aggregate;
         UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( Expression * member, Expression * aggregate );
         UntypedMemberExpr( const UntypedMemberExpr & other );
         virtual ~UntypedMemberExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * aggregate;
         MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
+        MemberExpr( DeclarationWithType * member, Expression * aggregate );
         MemberExpr( const MemberExpr & other );
         virtual ~MemberExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         DeclarationWithType * var;
         VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
+        VariableExpr( DeclarationWithType * var );
         VariableExpr( const VariableExpr & other );
         virtual ~VariableExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Constant constant;
         ConstantExpr( Constant constant, Expression *_aname = nullptr );
+        ConstantExpr( Constant constant );
         ConstantExpr( const ConstantExpr & other );
         virtual ~ConstantExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         SizeofExpr( Expression * expr, Expression *_aname = nullptr );
+        SizeofExpr( Expression * expr );
         SizeofExpr( const SizeofExpr & other );
         SizeofExpr( Type * type, Expression *_aname = nullptr );
+        SizeofExpr( Type * type );
         virtual ~SizeofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         AlignofExpr( Expression * expr, Expression *_aname = nullptr );
+        AlignofExpr( Expression * expr );
         AlignofExpr( const AlignofExpr & other );
         AlignofExpr( Type * type, Expression *_aname = nullptr );
+        AlignofExpr( Type * type );
         virtual ~AlignofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::string member;
         UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
+        UntypedOffsetofExpr( Type * type, const std::string & member );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
         virtual ~UntypedOffsetofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         DeclarationWithType * member;
         OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
+        OffsetofExpr( Type * type, DeclarationWithType * member );
         OffsetofExpr( const OffsetofExpr & other );
         virtual ~OffsetofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         StructInstType * type;
         OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
+        OffsetPackExpr( StructInstType * type );
         OffsetPackExpr( const OffsetPackExpr & other );
         virtual ~OffsetPackExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
+        AttrExpr(Expression * attr, Expression * expr );
         AttrExpr( const AttrExpr & other );
         AttrExpr( Expression * attr, Type * type, Expression *_aname = nullptr );
+        AttrExpr( Expression * attr, Type * type );
         virtual ~AttrExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg2;
         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
+        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
         LogicalExpr( const LogicalExpr & other );
         virtual ~LogicalExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
   private:
 …
         Expression * arg3;
         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
+        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
         ConditionalExpr( const ConditionalExpr & other );
         virtual ~ConditionalExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg2;
         CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
+        CommaExpr( Expression * arg1, Expression * arg2 );
         CommaExpr( const CommaExpr & other );
         virtual ~CommaExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> exprs;
         UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        UntypedTupleExpr( const std::list< Expression * > & exprs );
         UntypedTupleExpr( const UntypedTupleExpr & other );
         virtual ~UntypedTupleExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> exprs;
         TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        TupleExpr( const std::list< Expression * > & exprs );
         TupleExpr( const TupleExpr & other );
         virtual ~TupleExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         StmtExpr * stmtExpr = nullptr;
         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
+        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
         TupleAssignExpr( const TupleAssignExpr & other );
         virtual ~TupleAssignExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 private:
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };

src/SynTree/FunctionDecl.cc

-              rb96ec83
+              r6840e7c
+}
 void FunctionDecl::print( std::ostream &os, int indent ) const {
+void FunctionDecl::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
         if ( get_linkage() != LinkageSpec::Cforall ) {
                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         printAll( get_attributes(), os, indent );
+        printAll( attributes, os, indent );
         get_storageClasses().print( os );
         get_funcSpec().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";
 …
         if ( statements ) {
+                os << string( indent + 2, ' ' ) << "with body " << endl;
+                os << string( indent + 4, ' ' );
+                statements->print( os, indent + 4 );
+                os << indent << "... with body " << endl << indent+1;
+                statements->print( os, indent+1 );
         } // if
+}
 void FunctionDecl::printShort( std::ostream &os, int indent ) const {
+void FunctionDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
-        // xxx - should printShort print attributes?
         get_storageClasses().print( os );
         get_funcSpec().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/FunctionType.cc

-              rb96ec83
+              r6840e7c
+}
 void FunctionType::print( std::ostream &os, int indent ) const {
+void FunctionType::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
 …
         os << "function" << endl;
         if ( ! parameters.empty() ) {
                 os << string( indent + 2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent + 4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
                 if ( isVarArgs ) {
                         os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
+                        os << indent+1 << "and a variable number of other arguments" << endl;
                 } // if
         } else if ( isVarArgs ) {
                 os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
+                os << indent+1 << "accepting unspecified arguments" << endl;
         } // if
         os << string( indent + 2, ' ' ) << "returning ";
+        os << indent << "... returning ";
         if ( returnVals.empty() ) {
                 os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
+                os << "nothing " << endl;
         } else {
                 os << endl;
                 printAll( returnVals, os, indent + 4 );
+                printAll( returnVals, os, indent+1 );
         } // if
+}

src/SynTree/Initializer.cc

-              rb96ec83
+              r6840e7c
+}
 void Designation::print( std::ostream &os, int indent ) const {
+void Designation::print( std::ostream &os, Indenter indent ) const {
         if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
+                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
+                        os << std::string(indent + 4, ' ' );
+                        ( *i )->print(os, indent + 4 );
+                os << "... designated by: " << std::endl;
+                for ( const Expression * d : designators ) {
+                        os << indent+1;
+                        d->print(os, indent+1 );
+                        os << std::endl;
+                }
-                os << std::endl;
         } // if
+}
 …
+}
+void SingleInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+        os << std::string(indent+4, ' ' );
+        value->print( os, indent+4 );
+void SingleInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Simple Initializer: ";
+        value->print( os, indent );
+}
 …
+}
+void ListInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
+        for ( Designation * d : designations ) {
+                d->print( os, indent + 2 );
+        }
+        for ( const Initializer * init : initializers ) {
+                init->print( os, indent + 2 );
+void ListInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound initializer: " << std::endl;
+        for ( auto p : group_iterate( designations, initializers ) ) {
+                const Designation * d = std::get<0>(p);
+                const Initializer * init = std::get<1>(p);
+                os << indent+1;
+                init->print( os, indent+1 );
                 os << std::endl;
+                if ( ! d->designators.empty() ) {
+                        os << indent+1;
+                        d->print( os, indent+1 );
+                }
+        }
+}
 …
+}
 void ConstructorInit::print( std::ostream &os, int indent ) const {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
+void ConstructorInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Constructor initializer: " << std::endl;
         if ( ctor ) {
+                os << std::string(indent+2, ' ');
+                os << "initially constructed with ";
+                ctor->print( os, indent+4 );
+                os << indent << "... initially constructed with ";
+                ctor->print( os, indent+1 );
         } // if
         if ( dtor ) {
+                os << std::string(indent+2, ' ');
+                os << "destructed with ";
+                dtor->print( os, indent+4 );
+                os << indent << "... destructed with ";
+                dtor->print( os, indent+1 );
+        }
         if ( init ) {
+                os << std::string(indent+2, ' ');
+                os << "with fallback C-style initializer: ";
+                init->print( os, indent+4 );
+                os << indent << "... with fallback C-style initializer: ";
+                init->print( os, indent+1 );
+        }
+}

src/SynTree/Initializer.h

-              rb96ec83
+              r6840e7c
         std::list< Expression * > & get_designators() { return designators; }
         virtual Designation * clone() const { return new Designation( *this ); };
+        virtual Designation * clone() const override { return new Designation( *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 override;
+        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         bool get_maybeConstructed() { return maybeConstructed; }
         virtual Initializer *clone() const = 0;
+        virtual Initializer *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
+        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
   private:
         bool maybeConstructed;
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:

src/SynTree/Mutator.cc

-              rb96ec83
+              r6840e7c
+}
+TypeSubstitution * Mutator::mutate( TypeSubstitution * sub ) {
+        for ( auto & p : sub->typeEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        for ( auto & p : sub->varEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        return sub;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.h

-              rb96ec83
+              r6840e7c
         virtual Attribute * mutate( Attribute * attribute );
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub );
   private:
         virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl );

src/SynTree/NamedTypeDecl.cc

-              rb96ec83
+              r6840e7c
+}
 void NamedTypeDecl::print( std::ostream &os, int indent ) const {
+void NamedTypeDecl::print( std::ostream &os, Indenter indent ) const {
         using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( name != "" ) os << name << ": ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         get_storageClasses().print( os );
 …
         if ( base ) {
                 os << " for ";
                 base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! assertions.empty() ) {
                 os << endl << string( indent, ' ' ) << "with assertions" << endl;
                 printAll( assertions, os, indent+2 );
+                os << endl << indent << "... with assertions" << endl;
+                printAll( assertions, os, indent+1 );
         } // if
+}
 void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
+void NamedTypeDecl::printShort( std::ostream &os, Indenter indent ) const {
         using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        if ( name != "" ) os << name << ": ";
         get_storageClasses().print( os );
         os << typeString();
         if ( base ) {
                 os << " for ";
                 base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ObjectDecl.cc

-              rb96ec83
+              r6840e7c
+}
+void ObjectDecl::print( std::ostream &os, int indent ) const {
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+void ObjectDecl::print( std::ostream &os, Indenter indent ) const {
+        if ( name != "" ) os << name << ": ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
-        } // if
-        printAll( get_attributes(), os, indent );
         get_storageClasses().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << " untyped entity ";
 …
         if ( init ) {
+                os << " with initializer " << std::endl;
+                init->print( os, indent+2 );
+                os << std::endl << std::string(indent+2, ' ');
+                os << "maybeConstructed? " << init->get_maybeConstructed();
+                os << " with initializer (" << (init->get_maybeConstructed() ? "maybe constructed" : "not constructed") << ")" << std::endl << indent+1;
+                init->print( os, indent+1 );
+                os << std::endl;
         } // if
+        if ( ! attributes.empty() ) {
+                os << std::endl << indent << "... with attributes: " << std::endl;
+                printAll( attributes, os, indent+1 );
+        }
         if ( bitfieldWidth ) {
+                os << std::string(indent, ' ');
+                os << " with bitfield width ";
+                os << indent << " with bitfield width ";
                 bitfieldWidth->print( os );
         } // if
+}
 void ObjectDecl::printShort( std::ostream &os, int indent ) const {
+void ObjectDecl::printShort( std::ostream &os, Indenter indent ) const {
 #if 0
         if ( get_mangleName() != "") {
 …
         } else
 #endif
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        // xxx - should printShort print attributes?
+        if ( name != "" ) os << name << ": ";
         get_storageClasses().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/PointerType.cc

rb96ec83	r6840e7c
41	41	}
42	42
43		void PointerType::print( std::ostream &os, ~~int~~ indent ) const {
	43	void PointerType::print( std::ostream &os, Indenter indent ) const {
44	44	Type::print( os, indent );
45	45	if ( ! is_array() ) {

src/SynTree/ReferenceToType.cc

-              rb96ec83
+              r6840e7c
 //
-#include <stddef.h>          // for NULL
 #include <cassert>           // for assert
 #include <list>              // for list, _List_const_iterator, list<>::cons...
 …
+}
 void ReferenceToType::print( std::ostream &os, int indent ) const {
+void ReferenceToType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 …
         os << "instance of " << typeString() << " " << name << " ";
         if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}
 …
 std::list<TypeDecl*>* StructInstType::get_baseParameters() {
         if ( ! baseStruct ) return NULL;
+        if ( ! baseStruct ) return nullptr;
         return &baseStruct->get_parameters();
+}
 …
+}
 void StructInstType::print( std::ostream &os, int indent ) const {
+void StructInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         if ( baseStruct == NULL ) ReferenceToType::print( os, indent );
+        if ( baseStruct == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
                 if ( ! parameters.empty() ) {
                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                         printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
 …
 std::list< TypeDecl * > * UnionInstType::get_baseParameters() {
         if ( ! baseUnion ) return NULL;
+        if ( ! baseUnion ) return nullptr;
         return &baseUnion->get_parameters();
+}
 …
+}
 void UnionInstType::print( std::ostream &os, int indent ) const {
+void UnionInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         if ( baseUnion == NULL ) ReferenceToType::print( os, indent );
+        if ( baseUnion == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
                 if ( ! parameters.empty() ) {
                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                         printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
 …
 bool EnumInstType::isComplete() const { return baseEnum ? baseEnum->has_body() : false; }
+void EnumInstType::print( std::ostream &os, Indenter indent ) const {
+        using std::endl;
+        if ( baseEnum == nullptr ) ReferenceToType::print( os, indent );
+        else {
+                Type::print( os, indent );
+                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body() << " ";
+        } // if
+}
 std::string TraitInstType::typeString() const { return "trait"; }
 …
 bool TypeInstType::isComplete() const { return baseType->isComplete(); }
 void TypeInstType::print( std::ostream &os, int indent ) const {
+void TypeInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 …
         os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
         if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ReferenceType.cc

rb96ec83	r6840e7c
35	35	}
36	36
37		void ReferenceType::print( std::ostream &os, ~~int~~ indent ) const {
	37	void ReferenceType::print( std::ostream &os, Indenter indent ) const {
38	38	Type::print( os, indent );
39	39	os << "reference to ";

src/SynTree/Statement.cc

-              rb96ec83
+              r6840e7c
 Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
+void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
+void Statement::print( std::ostream & os, Indenter ) const {
+        if ( ! labels.empty() ) {
+                os << "Labels: {";
+                for ( const Label & l : labels ) {
+                        os << l << ",";
+                }
+                os << "}" << endl;
+        }
+}
 Statement::~Statement() {}
 …
+}
 void ExprStmt::print( std::ostream &os, int indent ) const {
         os << "Expression Statement:" << endl << std::string( indent + 2, ' ' );
         expr->print( os, indent + 2 );
+void ExprStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Expression Statement:" << endl << indent+1;
+        expr->print( os, indent+1 );
+}
 …
+}
 void AsmStmt::print( std::ostream &os, int indent ) const {
+void AsmStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
         os << std::string( indent, ' ' ) << "instruction: " << endl << std::string( indent, ' ' );
         instruction->print( os, indent + 2 );
+        os << indent+1 << "instruction: " << endl << indent;
+        instruction->print( os, indent+1 );
         if ( ! output.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "output: " << endl;
                 printAll( output, os, indent + 2 );
+                os << endl << indent+1 << "output: " << endl;
+                printAll( output, os, indent+1 );
         } // if
         if ( ! input.empty() ) {
                 os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
                 printAll( input, os, indent + 2 );
+                os << indent+1 << "input: " << endl;
+                printAll( input, os, indent+1 );
         } // if
         if ( ! clobber.empty() ) {
                 os << std::string( indent, ' ' ) << "clobber: " << endl;
                 printAll( clobber, os, indent + 2 );
+                os << indent+1 << "clobber: " << endl;
+                printAll( clobber, os, indent+1 );
         } // if
+}
 …
+}
 void BranchStmt::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' ) << "Branch (" << brType[type] << ")" << endl ;
         if ( target != "" ) os << string( indent+2, ' ' ) << "with target: " << target << endl;
         if ( originalTarget != "" ) os << string( indent+2, ' ' ) << "with original target: " << originalTarget << endl;
         if ( computedTarget != nullptr ) os << string( indent+2, ' ' ) << "with computed target: " << computedTarget << endl;
+void BranchStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Branch (" << brType[type] << ")" << endl ;
+        if ( target != "" ) os << indent+1 << "with target: " << target << endl;
+        if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
+        if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
+}
 …
+}
 void ReturnStmt::print( std::ostream &os, int indent ) const {
         os <<  "Return Statement, returning: ";
         if ( expr != 0 ) {
                 os << endl << string( indent+2, ' ' );
                 expr->print( os, indent + 2 );
+void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Return Statement, returning: ";
+        if ( expr != nullptr ) {
+                os << endl << indent+1;
+                expr->print( os, indent+1 );
+        }
         os << endl;
 …
+}
 void IfStmt::print( std::ostream &os, int indent ) const {
         os << "If on condition: " << endl ;
         os << string( indent+4, ' ' );
         condition->print( os, indent + 4 );
+void IfStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "If on condition: " << endl;
+        os << indent+1;
+        condition->print( os, indent+1 );
         if ( !initialization.empty() ) {
                 os << string( indent + 2, ' ' ) << "initialization: \n";
                 for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
                         os << string( indent + 4, ' ' );
                         (*it)->print( os, indent + 4 );
+                os << indent << "... with initialization: \n";
+                for ( const Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
+                }
                 os << endl;
+        }
         os << string( indent+2, ' ' ) << "... then: " << endl;
         os << string( indent+4, ' ' );
         thenPart->print( os, indent + 4 );
+        os << indent << "... then: " << endl;
+        os << indent+1;
+        thenPart->print( os, indent+1 );
         if ( elsePart != 0 ) {
                 os << string( indent+2, ' ' ) << "... else: " << endl;
                 os << string( indent+4, ' ' );
                 elsePart->print( os, indent + 4 );
+                os << indent << "... else: " << endl;
+                os << indent+1;
+                elsePart->print( os, indent+1 );
         } // if
+}
 …
+}
 void SwitchStmt::print( std::ostream &os, int indent ) const {
+void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
         os << endl;
+        // statements
+        std::list<Statement *>::const_iterator i;
+        for ( i = statements.begin(); i != statements.end(); i++)
+                (*i)->print( os, indent + 4 );
+        //for_each( statements.begin(), statements.end(), mem_fun( bind1st(&Statement::print ), os ));
+        for ( const Statement * stmt : statements ) {
+                stmt->print( os, indent+1 );
+        }
+}
 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 )
+                throw SemanticError("default with conditions");
+        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
+}
 …
+}
+void CaseStmt::print( std::ostream &os, int indent ) const {
+        os << string( indent, ' ' );
+        if ( isDefault() )
+                os << "Default ";
+void CaseStmt::print( std::ostream &os, Indenter indent ) const {
+        if ( isDefault() ) os << "Default ";
         else {
                 os << "Case ";
+                condition->print( os );
+        } // if
+        os << endl;
+        std::list<Statement *>::const_iterator i;
+        for ( i = stmts.begin(); i != stmts.end(); i++)
+                (*i )->print( os, indent + 4 );
+                condition->print( os, indent );
+        } // if
+        os << endl;
+        for ( Statement * stmt : stmts ) {
+                stmt->print( os, indent+1 );
+        }
+}
 …
+}
 void WhileStmt::print( std::ostream &os, int indent ) const {
+void WhileStmt::print( std::ostream &os, Indenter indent ) const {
         os << "While on condition: " << endl ;
         condition->print( os, indent + 4 );
         os << string( indent, ' ' ) << ".... with body: " << endl;
         if ( body != 0 ) body->print( os, indent + 4 );
+        condition->print( os, indent+1 );
+        os << indent << "... with body: " << endl;
+        if ( body != 0 ) body->print( os, indent+1 );
+}
 …
+}
+void ForStmt::print( std::ostream &os, int indent ) const {
+        os << "Labels: {";
+        for ( std::list<Label>::const_iterator it = get_labels().begin(); it != get_labels().end(); ++it) {
+                os << *it << ",";
+        }
+        os << "}" << endl;
+        os << string( indent, ' ' ) << "For Statement" << endl ;
+        os << string( indent + 2, ' ' ) << "initialization: \n";
+        for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
+                os << string( indent + 4, ' ' );
+                (*it)->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
+        if ( condition != 0 ) {
+                os << string( indent + 4, ' ' );
+                condition->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
+        if ( increment != 0 ) {
+                os << string( indent + 4, ' ' );
+                increment->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
+void ForStmt::print( std::ostream &os, Indenter indent ) const {
+        Statement::print( os, indent ); // print labels
+        os << "For Statement" << endl;
+        if ( ! initialization.empty() ) {
+                os << indent << "... initialization: \n";
+                for ( Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
+                }
+        }
+        if ( condition != nullptr ) {
+                os << indent << "... condition: \n" << indent+1;
+                condition->print( os, indent+1 );
+        }
+        if ( increment != nullptr ) {
+                os << "\n" << indent << "... increment: \n" << indent+1;
+                increment->print( os, indent+1 );
+        }
         if ( body != 0 ) {
+                os << string( indent + 4, ' ' );
+                body->print( os, indent + 4 );
+        }
+                os << "\n" << indent << "... with body: \n" << indent+1;
+                body->print( os, indent+1 );
+        }
         os << endl;
+}
 …
+}
+void ThrowStmt::print( std::ostream &os, int indent) const {
+void ThrowStmt::print( std::ostream &os, Indenter indent) const {
+        if ( target ) os << "Non-Local ";
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent+1);
         if ( target ) {
+                os << "Non-Local ";
+        }
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent + 4);
+        if ( target ) {
+                os << "At: ";
+                target->print(os, indent + 4);
+                os << "... at: ";
+                target->print(os, indent+1);
+        }
+}
 …
+}
 void TryStmt::print( std::ostream &os, int indent ) const {
+void TryStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Try Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
         // handlers
         os << string( indent + 2, ' ' ) << "and handlers:" << endl;
         for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++) {
                 os << string( indent + 4, ' ' );
                 (*i )->print( os, indent + 4 );
+        os << indent << "... and handlers:" << endl;
+        for ( const CatchStmt * stmt : handlers ) {
+                os << indent+1;
+                stmt->print( os, indent+1 );
+        }
         // finally block
         if ( finallyBlock != 0 ) {
                 os << string( indent + 2, ' ' ) << "and finally:" << endl;
                 finallyBlock->print( os, indent + 4 );
+                os << indent << "... and finally:" << endl << indent+1;
+                finallyBlock->print( os, indent+1 );
         } // if
+}
 …
 CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
         Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+                assertf( decl, "Catch clause must have a declaration." );
+}
 …
+}
 void CatchStmt::print( std::ostream &os, int indent ) const {
+void CatchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
+        os << string( indent + 2, ' ' ) << "... catching: ";
+        if ( decl ) {
+                decl->printShort( os, indent + 4 );
+                os << endl;
+        }
+        else
+                os << string( indent + 4 , ' ' ) << ">>> Error:  this catch clause must have a declaration <<<" << endl;
+        os << indent << "... catching: ";
+        decl->printShort( os, indent+1 );
+        os << endl;
         if ( cond ) {
+                os << string( indent + 2, ' ' ) << "with conditional:" << endl;
+                os << string( indent + 4, ' ' );
+                cond->print( os, indent + 4 );
+        }
+        else
+                os << string( indent + 2, ' ' ) << "with no conditional" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        body->print( os, indent + 4 );
+                os << indent << "... with conditional:" << endl << indent+1;
+                cond->print( os, indent+1 );
+        }
+        os << indent << "... with block:" << endl;
+        os << indent+1;
+        body->print( os, indent+1 );
+}
 …
+}
 void FinallyStmt::print( std::ostream &os, int indent ) const {
+void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Finally Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
+}
 …
+}
 void WaitForStmt::print( std::ostream &os, int indent ) const {
+void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        os << indent << "... with block:" << endl << indent+1;
         // block->print( os, indent + 4 );
+}
 …
 NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
 void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "Null Statement" << endl ;
+void NullStmt::print( std::ostream &os, Indenter ) const {
+        os << "Null Statement" << endl;
+}
 …
+}
 void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
+void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
         os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
         callStmt->print( os, indent + 2);
+        os << indent << "... with Ctor/Dtor: ";
+        callStmt->print( os, indent+1);
         os << endl;
+}

src/SynTree/Statement.h

-              rb96ec83
+              r6840e7c
         const std::list<Label> & get_labels() const { return labels; }
         virtual Statement *clone() const = 0;
+        virtual Statement *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual Statement *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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 void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         static const char *brType[];
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };

src/SynTree/TupleExpr.cc

-              rb96ec83
+              r6840e7c
 #include "Type.h"               // for TupleType, Type
 UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
+}
 …
+}
 void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
+void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Untyped Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
+}
 TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+TupleExpr::TupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
         set_result( Tuples::makeTupleType( exprs ) );
+}
 …
+}
 void TupleExpr::print( std::ostream &os, int indent ) const {
+void TupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
+}
 …
+}
 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
+void TupleIndexExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Index Expression, with tuple:" << std::endl;
         os << std::string( indent+2, ' ' );
         tuple->print( os, indent+2 );
         os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
+        os << indent+1;
+        tuple->print( os, indent+1 );
+        os << indent+1 << "with index: " << index << std::endl;
         Expression::print( os, indent );
+}
 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
+TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls ) : Expression() {
         // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
         set_result( Tuples::makeTupleType( assigns ) );
 …
+}
 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
+void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
         os << std::string( indent+2, ' ' );
         stmtExpr->print( os, indent+4 );
+        os << indent+1;
+        stmtExpr->print( os, indent+1 );
         Expression::print( os, indent );
+}

src/SynTree/TupleType.cc

rb96ec83	r6840e7c
48	48	}
49	49
50		void TupleType::print( std::ostream &os, ~~int~~ indent ) const {
	50	void TupleType::print( std::ostream &os, Indenter indent ) const {
51	51	Type::print( os, indent );
52	52	os << "tuple of types" << std::endl;
53		printAll( types, os, indent+2 );
	53	printAll( types, os, indent+1 );
54	54	}
55	55

src/SynTree/Type.cc

-              rb96ec83
+              r6840e7c
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 11 13:21:25 2017
 // Update Count     : 37
+// Last Modified On : Mon Sep 25 15:16:32 2017
+// Update Count     : 38
 //
 #include "Type.h"
 …
         "double _Imaginary",
         "long double _Imaginary",
+        "__int128",
+        "unsigned __int128",
 };
 …
         Type * type;
         ReferenceType * ref;
         for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
+        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->base );
         return type;
+}
 …
 int Type::referenceDepth() const { return 0; }
 void Type::print( std::ostream &os, int indent ) const {
+void Type::print( std::ostream &os, Indenter indent ) const {
         if ( ! forall.empty() ) {
                 os << "forall" << std::endl;
                 printAll( forall, os, indent + 4 );
                 os << std::string( indent+2, ' ' );
+                printAll( forall, os, indent+1 );
+                os << ++indent;
         } // if
         if ( ! attributes.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
                 printAll( attributes, os, indent+4 );
+                os << "with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if

src/SynTree/Type.h

-              rb96ec83
+              r6840e7c
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 14:25:00 2017
 // Update Count     : 152
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 14:14:01 2017
+// Update Count     : 154
 //
 …
         virtual void accept( Visitor & v ) = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
                 DoubleImaginary,
                 LongDoubleImaginary,
+                SignedInt128,
+                UnsignedInt128,
                 NUMBER_OF_BASIC_TYPES
         } kind;
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         bool isInteger() const;
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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 print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
 …
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
 …
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
 …
         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, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         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;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/SynTree/TypeDecl.cc

rb96ec83	r6840e7c
41	41	}
42	42
43		void TypeDecl::print( std::ostream &os, ~~int~~ indent ) const {
	43	void TypeDecl::print( std::ostream &os, Indenter indent ) const {
44	44	NamedTypeDecl::print( os, indent );
45	45	if ( init ) {
46		os << std::endl << ~~std::string( indent, ' ' )~~ << "with type initializer: ";
47		init->print( os, indent + 2 );
	46	os << std::endl << indent << "with type initializer: ";
	47	init->print( os, indent + 1 );
48	48	}
49	49	}

src/SynTree/TypeExpr.cc

rb96ec83	r6840e7c
30	30	}
31	31
32		void TypeExpr::print( std::ostream &os, ~~int~~ indent ) const {
	32	void TypeExpr::print( std::ostream &os, Indenter indent ) const {
33	33	if ( type ) type->print( os, indent );
34	34	Expression::print( os, indent );

src/SynTree/TypeSubstitution.cc

-              rb96ec83
+              r6840e7c
 template< typename TypeClass >
 Type *TypeSubstitution::handleType( TypeClass *type ) {
         BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
 …
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
+}
 …
 template< typename TypeClass >
 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
         BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
 …
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
+}
 …
+}
+TypeSubstitution * TypeSubstitution::acceptMutator( Mutator & mutator ) {
+        for ( auto & p : typeEnv ) {
+                p.second = maybeMutate( p.second, mutator );
+        }
+        for ( auto & p : varEnv ) {
+                p.second = maybeMutate( p.second, mutator );
+        }
+        return this;
+}
+void TypeSubstitution::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Types:" << std::endl;
+void TypeSubstitution::print( std::ostream &os, Indenter indent ) const {
+        os << indent << "Types:" << std::endl;
         for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
                 os << std::string( indent+2, ' ' ) << i->first << " -> ";
                 i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for
         os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
+        os << indent << "Non-types:" << std::endl;
         for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
                 os << std::string( indent+2, ' ' ) << i->first << " -> ";
                 i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for

src/SynTree/TypeSubstitution.h

-              rb96ec83
+              r6840e7c
         void normalize();
         TypeSubstitution * acceptMutator( Mutator & mutator );
+        TypeSubstitution * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         void print( std::ostream &os, int indent = 0 ) const;
+        void print( std::ostream &os, Indenter indent = {} ) const;
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
 …
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
+        friend class Mutator;
+        template<typename pass_type>
+        friend class PassVisitor;
         typedef std::map< std::string, Type* > TypeEnvType;

src/SynTree/TypeofType.cc

-              rb96ec83
+              r6840e7c
 // file "LICENCE" distributed with Cforall.
 //
 // TypeofType.cc --
+// TypeofType.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void TypeofType::print( std::ostream &os, int indent ) const {
+void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "type-of expression ";

src/SynTree/VarArgsType.cc

rb96ec83	r6840e7c
25	25	VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
26	26
27		void VarArgsType::print( std::ostream &os, ~~int~~ indent ) const {
	27	void VarArgsType::print( std::ostream &os, Indenter indent ) const {
28	28	Type::print( os, indent );
29	29	os << "builtin var args pack";

src/SynTree/VoidType.cc

-              rb96ec83
+              r6840e7c
 // file "LICENCE" distributed with Cforall.
 //
 // VoidType.cc --
+// VoidType.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void VoidType::print( std::ostream &os, int indent ) const {
+void VoidType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "void ";

src/SynTree/ZeroOneType.cc

-              rb96ec83
+              r6840e7c
 ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void ZeroType::print( std::ostream &os, Indenter ) const {
         os << "zero_t";
+}
 …
 OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void OneType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void OneType::print( std::ostream &os, Indenter ) const {
         os << "one_t";
+}

src/Tuples/Explode.h

-              rb96ec83
+              r6840e7c
         Expression * distributeReference( Expression * );
+        static inline CastExpr * isReferenceCast( Expression * expr ) {
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                        if ( dynamic_cast< ReferenceType * >( castExpr->result ) ) {
+                                return castExpr;
+                        }
+                }
+                return nullptr;
+        }
         /// helper function used by explode
         template< typename OutputIterator >
 …
                 if ( isTupleAssign ) {
                         // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
                         if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                        if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
                                 ResolvExpr::AltList alts;
                                 explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );

src/Tuples/TupleAssignment.cc

-              rb96ec83
+              r6840e7c
 #include "SynTree/Visitor.h"               // for Visitor
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 namespace Tuples {
         class TupleAssignSpotter {
 …
         bool isTuple( Expression *expr ) {
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
+                assert( expr->result );
                 return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+        }
 …
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
                         if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
+                                fname = op->get_name();
+                               fname = op->get_name();
+                                PRINT( std::cerr << "TupleAssignment: " << fname << std::endl; )
                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
 …
                                         const ResolvExpr::Alternative & alt1 = ali->front();
                                         auto begin = std::next(ali->begin(), 1), end = ali->end();
+                                        PRINT( std::cerr << "alt1 is " << alt1.expr << std::endl; )
                                         if ( refToTuple(alt1.expr) ) {
+                                                PRINT( std::cerr << "and is reference to tuple" << std::endl; )
                                                 if ( isMultAssign( begin, end ) ) {
+                                                        PRINT( std::cerr << "possible multiple assignment" << std::endl; )
                                                         matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
                                                 } else {
                                                         // mass assignment
+                                                        PRINT( std::cerr << "possible mass assignment" << std::endl; )
                                                         matcher.reset( new MassAssignMatcher( *this,  *ali ) );
+                                                }
 …
                 // now resolve new assignments
                 for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                        PRINT(
+                                std::cerr << "== resolving tuple assign ==" << std::endl;
+                                std::cerr << *i << std::endl;
+                        )
                         ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
                         try {
 …
         ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
+                assert( expr->result && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
                 // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
 …
                         ctorInit->accept( rm );
+                }
+                PRINT( std::cerr << "new object: " << ret << std::endl; )
                 return ret;
+        }

src/benchmark/Makefile.am

-              rb96ec83
+              r6840e7c
         @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

-              rb96ec83
+              r6840e7c
         @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

rb96ec83	r6840e7c
10	10	}
11	11	#endif
12
13	12
14	13	static inline unsigned long long int Time() {

src/benchmark/create_cfaThrd.c

rb96ec83	r6840e7c
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/driver/cfa.cc

-              rb96ec83
+              r6840e7c
 // Author           : Peter A. Buhr
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug 17 15:24:00 2017
 // Update Count     : 156
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Sep 26 23:12:38 2017
+// Update Count     : 159
 //
 …
                 args[nargs] = "-fgnu89-inline";
                 nargs += 1;
+                args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
+                nargs += 1;
                 args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
                 nargs += 1;

src/include/cassert

rb96ec83	r6840e7c
41	41	static inline T strict_dynamic_cast( const U & src ) {
42	42	T ret = dynamic_cast<T>(src);
43		assert~~(ret~~);
	43	assertf(ret, "%s", toString(src).c_str());
44	44	return ret;
45	45	}

src/libcfa/Makefile.am

-              rb96ec83
+              r6840e7c
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@

src/libcfa/Makefile.in

-              rb96ec83
+              r6840e7c
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 # extensionless header files are overridden by -o flag in default makerule => explicitly override default rule to silently do nothing

src/libcfa/concurrency/invoke.h

-              rb96ec83
+              r6840e7c
             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 __waitfor_mask_t mask;             // mask used to know if some thread is waiting for something while holding the monitor
+            struct __condition_node_t * dtor_node;    // node used to signal the dtor in a waitfor dtor
       };
 …
             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
+            struct __monitor_group_t monitors;        // monitors currently held by this thread
             // Link lists fields

src/libcfa/concurrency/monitor

-              rb96ec83
+              r6840e7c
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:01 2017
 // Update Count     : 3
+// Last Modified On : Sat Oct  7 18:06:45 2017
+// Update Count     : 10
 //
 …
 static inline void ?{}(monitor_desc & this) {
         (this.lock){};
-        this.owner = NULL;
         (this.entry_queue){};
         (this.signal_stack){};
+        this.recursion = 0;
+        this.owner         = NULL;
+        this.recursion     = 0;
         this.mask.accepted = NULL;
         this.mask.clauses  = NULL;
         this.mask.size     = 0;
+        this.dtor_node     = NULL;
+}
+// static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
+//      return ((intptr_t)lhs) < ((intptr_t)rhs);
+// }
 struct monitor_guard_t {
 …
 };
-static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
-        return ((intptr_t)lhs) < ((intptr_t)rhs);
+}
 void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
+struct monitor_dtor_guard_t {
+        monitor_desc * m;
+        monitor_desc ** prev_mntrs;
+        unsigned short  prev_count;
+        fptr_t          prev_func;
+};
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ^?{}( monitor_dtor_guard_t & this );
+static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } )
+void delete( T * th ) {
+        ^(*th){};
+        free( th );
+}
 //-----------------------------------------------------------------------------
 …
         __condition_node_t ** tail;
 };
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info );
+void ?{}(__condition_criterion_t & this );
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 void ?{}( __condition_blocked_queue_t & );

src/libcfa/concurrency/monitor.c

-              rb96ec83
+              r6840e7c
 //-----------------------------------------------------------------------------
 // Forward declarations
+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 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 );
 …
 #define monitor_restore restore( monitors, count, locks, recursions, masks )
-#define blockAndWake( thrd, cnt )                               /* Create the necessary information to use the signaller stack                         */ \
-        monitor_save;                                             /* Save monitor states                                                                 */ \
-        BlockInternal( locks, count, thrd, cnt );                 /* Everything is ready to go to sleep                                                  */ \
-        monitor_restore;                                          /* We are back, restore the owners and recursions                                      */ \
 //-----------------------------------------------------------------------------
 …
+                }
                 else if( this->owner == thrd) {
                         // We already have the monitor, just not how many times we took it
+                        // We already have the monitor, just note how many times we took it
                         verify( this->recursion > 0 );
                         this->recursion += 1;
 …
                         set_owner( this, thrd );
+                        // Reset mask
+                        reset_mask( this );
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
+                }
 …
                 unlock( &this->lock );
                 return;
+        }
+        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
+                // Lock the monitor spinlock, lock_yield to reduce contention
+                lock_yield( &this->lock DEBUG_CTX2 );
+                thread_desc * thrd = this_thread;
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                if( !this->owner ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
+                        // No one has the monitor, just take it
+                        set_owner( this, thrd );
+                        unlock( &this->lock );
+                        return;
+                }
+                else if( this->owner == thrd) {
+                        // We already have the monitor... but where about to destroy it so the nesting will fail
+                        // Abort!
+                        abortf("Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.");
+                }
+                int count = 1;
+                monitor_desc ** monitors = &this;
+                __monitor_group_t group = { &this, 1, func };
+                if( is_accepted( this, group) ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
+                        // Wake the thread that is waiting for this
+                        __condition_criterion_t * urgent = pop( &this->signal_stack );
+                        verify( urgent );
+                        // Reset mask
+                        reset_mask( this );
+                        // Create the node specific to this wait operation
+                        wait_ctx_primed( this_thread, 0 )
+                        // Some one else has the monitor, wait for him to finish and then run
+                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+                }
+                else {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+                        wait_ctx( this_thread, 0 )
+                        this->dtor_node = &waiter;
+                        // Some one else has the monitor, wait in line for it
+                        append( &this->entry_queue, thrd );
+                        BlockInternal( &this->lock );
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
+                LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
+        }
 …
+        }
+        // Leave single monitor for the last time
+        void __leave_dtor_monitor_desc( monitor_desc * this ) {
+                LIB_DEBUG_DO(
+                        if( this_thread != this->owner ) {
+                                abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                        }
+                        if( this->recursion != 1 ) {
+                                abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
+        }
         // Leave the thread monitor
         // last routine called by a thread.
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, fptr_t func ) {
         // Store current array
         this.m = m;
 …
         this_thread->monitors.func = func;
         LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
         // Enter the monitors in order
 …
         enter( group );
         LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+        // 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);
+        // 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");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+        // Restore thread context
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+}
+// Ctor for monitor guard
+// Sorts monitors before entering
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, fptr_t func ) {
+        // Store current array
+        this.m = *m;
+        // Save previous thread context
+        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->monitors.list = m;
+        this_thread->monitors.size = 1;
+        this_thread->monitors.func = func;
+        __enter_monitor_dtor( this.m, func );
+}
+// Dtor for monitor guard
+void ^?{}( monitor_dtor_guard_t & this ) {
+        // Leave the monitors in order
+        __leave_dtor_monitor_desc( this.m );
         // Restore thread context
 …
         short thread_count = 0;
         thread_desc * threads[ count ];
+        for(int i = 0; i < count; i++) {
+                threads[i] = 0;
+        }
+        __builtin_memset( threads, 0, sizeof( threads ) );
         // Save monitor states
 …
         short max = count_max( mask );
         monitor_desc * mon_storage[max];
+        __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         short actual_count = aggregate( mon_storage, mask );
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
         if(actual_count == 0) return;
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
         // Create storage for monitor context
 …
                 if( next ) {
+                        *mask.accepted = index;
                         if( mask.clauses[index].is_dtor ) {
+                                #warning case not implemented
+                                LIB_DEBUG_PRINT_SAFE("Kernel : dtor already there\n");
+                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
+                                monitor_desc * mon2dtor = mask.clauses[index].list[0];
+                                verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
+                                __condition_criterion_t * dtor_crit = mon2dtor->dtor_node->criteria;
+                                push( &mon2dtor->signal_stack, dtor_crit );
+                                unlock_all( locks, count );
+                        }
                         else {
+                                blockAndWake( &next, 1 );
+                                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");
+                        }
+                        return index;
+                        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( this_thread, 0 );
         monitor_save;
         set_mask( monitors, count, mask );
+        BlockInternal( locks, count );       // Everything is ready to go to sleep
+        //WE WOKE UP
+        monitor_restore;                     //We are back, restore the masks and recursions
+        for(int i = 0; i < count; i++) {
+                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 );
+        // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
         //Pass the monitor appropriately
 …
                 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 void save   ( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+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;

src/libcfa/iostream

-              rb96ec83
+              r6840e7c
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 13 12:53:46 2017
 // Update Count     : 138
+// Last Modified On : Tue Oct 10 14:51:10 2017
+// Update Count     : 140
 //
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char16_t * );
+#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char32_t * );
+#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const wchar_t * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );

src/libcfa/iostream.c

-              rb96ec83
+              r6840e7c
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 17 23:24:25 2017
 // Update Count     : 422
+// Last Modified On : Tue Oct 10 14:51:09 2017
+// Update Count     : 424
 //
 …
 } // ?|?
+#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, const char32_t * str ) {
 …
         return os;
 } // ?|?
+#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
 forall( dtype ostype | ostream( ostype ) )

src/main.cc

-              rb96ec83
+              r6840e7c
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
-#include "GenPoly/CopyParams.h"             // for copyParams
 #include "GenPoly/InstantiateGeneric.h"     // for instantiateGeneric
 #include "GenPoly/Lvalue.h"                 // for convertLvalue
 …
                 OPTPRINT("instantiateGenerics")
                 GenPoly::instantiateGeneric( translationUnit );
-                OPTPRINT( "copyParams" );
-                GenPoly::copyParams( translationUnit );
                 OPTPRINT( "convertLvalue" )
                 GenPoly::convertLvalue( translationUnit );

src/prelude/extras.c

rb96ec83	r6840e7c
1	1	#include <stddef.h> // size_t, ptrdiff_t
	2	#include <stdint.h> // intX_t, uintX_t, where X is 8, 16, 32, 64
2	3	#include <uchar.h> // char16_t, char32_t
3	4	#include <wchar.h> // wchar_t

src/prelude/extras.regx

-              rb96ec83
+              r6840e7c
 typedef.* size_t;
 typedef.* ptrdiff_t;
+typedef.* int8_t;
+typedef.* int16_t;
+typedef.* int32_t;
+typedef.* int64_t;
+typedef.* uint8_t;
+typedef.* uint16_t;
+typedef.* uint32_t;
+typedef.* uint64_t;
 typedef.* char16_t;
 typedef.* char32_t;

src/prelude/prelude.cf

-              rb96ec83
+              r6840e7c
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 30 07:56:07 2017
 // Update Count     : 93
+// Last Modified On : Sun Oct  8 12:21:33 2017
+// Update Count     : 97
 //
 …
 signed long long int    ?+=?( signed long long int &, signed long long int ),   ?+=?( volatile signed long long int &, signed long long int );
 unsigned long long int  ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int );
+//signed int128         ?+=?( signed int128 &, signed int128 ),                 ?+=?( volatile signed int128 &, signed int128 );
+//unsigned int128               ?+=?( unsigned int128 &, unsigned int128 ),             ?+=?( volatile unsigned int128 &, unsigned int128 );
 _Bool                   ?-=?( _Bool &, _Bool ),                                 ?-=?( volatile _Bool &, _Bool );

src/tests/.expect/32/KRfunctions.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
 …
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
 …
     signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ___retval_f10__PFPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{

src/tests/.expect/32/attributes.txt

-              rb96ec83
+              r6840e7c
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 __attribute__ ((unused)) struct Agn1;
 …
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    return ___ret__5sAgn2_1;
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1);
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1);
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1);
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1);
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1);
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object1);
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object2, signed int *__f9__Pi_1);
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
+    return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object3){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object4, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 …
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
 __attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
 signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
 signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned int )5)]));
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int __ad__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_ad__i_1;
 …
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
+        return ___ret__13s__anonymous4_2;
+    }
     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
 …
+    }
     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
 …
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        return ___ret__13e__anonymous5_2;
+    }
     ((void)sizeof(enum __anonymous5 ));
+}
 signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
 signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
 signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int __anonymous_object28;
     __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned int )10)];
     __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object32;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
+    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 …
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object36);
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object37, signed int *__anonymous_object38);
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object39, signed int *__anonymous_object40, signed int __anonymous_object41[((unsigned int )10)]);
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object42, signed int *__anonymous_object43, signed int __anonymous_object44[((unsigned int )10)], signed int (*__anonymous_object45)());
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index0 = 0;
+        for (;(_index0<10);((void)(++_index0))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index0])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
+        signed int _index1 = 0;
+        for (;(_index1<10);((void)(++_index1))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index1])))=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
+        signed int _index2 = (10-1);
+        for (;(_index2>=0);((void)(--_index2))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index2])))) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
+}
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
+    {
+        signed int _index3 = 0;
+        for (;(_index3<10);((void)(++_index3))) {
+            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
+    return ___ret__4sVad_1;
+}
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object46){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index4 = 0;
+        for (;(_index4<10);((void)(++_index4))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index4])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object47, signed int *__anonymous_object48){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
+        signed int _index5 = 0;
+        for (;(_index5<10);((void)(++_index5))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index5])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object49, signed int *__anonymous_object50, signed int __anonymous_object51[((unsigned int )10)]){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
+        signed int _index6 = 0;
+        for (;(_index6<10);((void)(++_index6))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index6])))=__anonymous_object51[_index6]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object52, signed int *__anonymous_object53, signed int __anonymous_object54[((unsigned int )10)], signed int (*__anonymous_object55)()){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
+        signed int _index7 = 0;
+        for (;(_index7<10);((void)(++_index7))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index7])))=__anonymous_object54[_index7]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/32/declarationSpecifier.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__R13s__anonymous1_1)));
+    return ___ret__13s__anonymous1_1;
+}
 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__R13s__anonymous2_1)));
+    return ___ret__13s__anonymous2_1;
+}
 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__R13s__anonymous3_1)));
+    return ___ret__13s__anonymous3_1;
+}
 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__R13s__anonymous4_1)));
+    return ___ret__13s__anonymous4_1;
+}
 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__R13s__anonymous5_1)));
+    return ___ret__13s__anonymous5_1;
+}
 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__R13s__anonymous6_1)));
+    return ___ret__13s__anonymous6_1;
+}
 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__R13s__anonymous7_1)));
+    return ___ret__13s__anonymous7_1;
+}
 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__R13s__anonymous8_1)));
+    return ___ret__13s__anonymous8_1;
+}
 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__R13s__anonymous9_1)));
+    return ___ret__13s__anonymous9_1;
+}
 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__R14s__anonymous10_1)));
+    return ___ret__14s__anonymous10_1;
+}
 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__R14s__anonymous11_1)));
+    return ___ret__14s__anonymous11_1;
+}
 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__R14s__anonymous12_1)));
+    return ___ret__14s__anonymous12_1;
+}
 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__R14s__anonymous13_1)));
+    return ___ret__14s__anonymous13_1;
+}
 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__R14s__anonymous14_1)));
+    return ___ret__14s__anonymous14_1;
+}
 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__R14s__anonymous15_1)));
+    return ___ret__14s__anonymous15_1;
+}
 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__R14s__anonymous16_1)));
+    return ___ret__14s__anonymous16_1;
+}
 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__R14s__anonymous17_1)));
+    return ___ret__14s__anonymous17_1;
+}
 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__R14s__anonymous18_1)));
+    return ___ret__14s__anonymous18_1;
+}
 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__R14s__anonymous19_1)));
+    return ___ret__14s__anonymous19_1;
+}
 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__R14s__anonymous20_1)));
+    return ___ret__14s__anonymous20_1;
+}
 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__R14s__anonymous21_1)));
+    return ___ret__14s__anonymous21_1;
+}
 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__R14s__anonymous22_1)));
+    return ___ret__14s__anonymous22_1;
+}
 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__R14s__anonymous23_1)));
+    return ___ret__14s__anonymous23_1;
+}
 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
 …
     __attribute__ ((unused)) signed int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/32/extension.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1) /* ?{} */);
 …
     ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
 …
     __extension__ signed int __c__i_1;
 };
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1);
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 …
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__R2uU_1)));
+    return ___ret__2uU_1;
+}
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
+    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
+    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/32/gccExtensions.txt

-              rb96ec83
+              r6840e7c
         ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
 …
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = ((signed int )__extension__ 3);
+    signed int __i__i_2 = __extension__ 3;
     __extension__ signed int __a__i_2;
     __extension__ signed int __b__i_2;
 …
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__R3ss2_2)));
+        return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
 …
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__R3ss3_2)));
+        return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
 …
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__R3ss4_2)));
+        return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
 …
     signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}

src/tests/.expect/32/literals.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1);
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
 …
     struct _Istream_cstrUC ___ret__16s_Istream_cstrUC_1;
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
     ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), ___src__16s_Istream_cstrUC_1));
     return ((struct _Istream_cstrUC )___ret__16s_Istream_cstrUC_1);
+    ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__R16s_Istream_cstrUC_1)));
+    return ___ret__16s_Istream_cstrUC_1;
+}
 static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1){
 …
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1);
 static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
 static inline void ___constructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
 …
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
     ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), ___src__15s_Istream_cstrC_1));
     return ((struct _Istream_cstrC )___ret__15s_Istream_cstrC_1);
+    ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__R15s_Istream_cstrC_1)));
+    return ___ret__15s_Istream_cstrC_1;
+}
 static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1){
 …
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = ((signed int )16),
+    __sepSize__C13e__anonymous0_1 = 16,
 };
 struct ofstream {
 …
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]);
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = ((signed int )0);
+        signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index0])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index1 = ((signed int )0);
+    {
+        signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index1])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = ((signed int )0);
+        signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index2])))=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
 …
+    }
+    {
+        signed int _index3 = ((signed int )0);
+    {
+        signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index3])))=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
 …
+    }
+}
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
+    {
         signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4])))) /* ^?{} */);
 …
+    }
+    {
+        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+    {
+        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index5])))) /* ^?{} */);
 …
+    }
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ^?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         signed int _index6 = ((signed int )0);
+        signed int _index6 = 0;
         for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index6]=___src__9sofstream_1.__separator__A0c_1[_index6]));
 …
+    {
         signed int _index7 = ((signed int )0);
+        signed int _index7 = 0;
         for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index7]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index7]));
 …
+    }
     ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), ___src__9sofstream_1));
     return ((struct ofstream )___ret__9sofstream_1);
+    ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__R9sofstream_1)));
+    return ___ret__9sofstream_1;
+}
 static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = ((signed int )0);
+        signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index8])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index9 = ((signed int )0);
+    {
+        signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index9])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = ((signed int )0);
+        signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index10])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index11 = ((signed int )0);
+    {
+        signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index11])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = ((signed int )0);
+        signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index12])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index13 = ((signed int )0);
+    {
+        signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index13])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = ((signed int )0);
+        signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index14])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index15 = ((signed int )0);
+    {
+        signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index15])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = ((signed int )0);
+        signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index16])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index17 = ((signed int )0);
+    {
+        signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index17])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = ((signed int )0);
+        signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index18])))=__separator__A0c_1[_index18]) /* ?{} */);
 …
+    }
+    {
+        signed int _index19 = ((signed int )0);
+    {
+        signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = ((signed int )0);
+        signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index20])))=__separator__A0c_1[_index20]) /* ?{} */);
 …
+    }
+    {
+        signed int _index21 = ((signed int )0);
+    {
+        signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21])))=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
 …
+    }
+}
 _Bool __sepPrt__Fb_P9sofstream__1(struct ofstream *__anonymous_object1294);
 …
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline struct ifstream ___operator_assign__F9sifstream_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1);
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1) /* ?{} */);
 …
     struct ifstream ___ret__9sifstream_1;
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
     ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), ___src__9sifstream_1));
     return ((struct ifstream )___ret__9sifstream_1);
+    ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__R9sifstream_1)));
+    return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
 …
     ((void)0123456789.e-09L);
     ((void)0123456789.e-09DL);
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
     ((void)(-0123456789.e-09l));
     ((void)(-0123456789.e-09F));
     ((void)(-0123456789.e-09L));
     ((void)(-0123456789.e-09DL));
+    ((void)(+0123456789.e-09));
+    ((void)(+0123456789.e-09f));
+    ((void)(+0123456789.e-09l));
+    ((void)(+0123456789.e-09F));
+    ((void)(+0123456789.e-09L));
+    ((void)(+0123456789.e-09DL));
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
 …
     ((void)0123456789.0123456789E-09L);
     ((void)0123456789.0123456789E-09DL);
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
     ((void)(-0123456789.0123456789E-09l));
     ((void)(-0123456789.0123456789E-09F));
     ((void)(-0123456789.0123456789E-09L));
     ((void)(-0123456789.0123456789E-09DL));
+    ((void)(+0123456789.0123456789E-09));
+    ((void)(+0123456789.0123456789E-09f));
+    ((void)(+0123456789.0123456789E-09l));
+    ((void)(+0123456789.0123456789E-09F));
+    ((void)(+0123456789.0123456789E-09L));
+    ((void)(+0123456789.0123456789E-09DL));
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
 …
     ((void)0x0123456789.p-09F);
     ((void)0x0123456789.p-09L);
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
     ((void)(-0x0123456789.p-09l));
     ((void)(-0x0123456789.p-09F));
     ((void)(-0x0123456789.p-09L));
+    ((void)(+0x0123456789.p-09));
+    ((void)(+0x0123456789.p-09f));
+    ((void)(+0x0123456789.p-09l));
+    ((void)(+0x0123456789.p-09F));
+    ((void)(+0x0123456789.p-09L));
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
 …
     ((void)0x.0123456789P-09F);
     ((void)0x.0123456789P-09L);
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
     ((void)(-0x.0123456789P-09l));
     ((void)(-0x.0123456789P-09F));
     ((void)(-0x.0123456789P-09L));
+    ((void)(+0x.0123456789P-09));
+    ((void)(+0x.0123456789P-09f));
+    ((void)(+0x.0123456789P-09l));
+    ((void)(+0x.0123456789P-09F));
+    ((void)(+0x.0123456789P-09L));
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
 …
     ((void)0X0123456789.0123456789P-09F);
     ((void)0X0123456789.0123456789P-09L);
+    ((void)(+0X0123456789.0123456789P-09));
+    ((void)(+0X0123456789.0123456789P-09f));
+    ((void)(+0X0123456789.0123456789P-09l));
+    ((void)(+0X0123456789.0123456789P-09F));
+    ((void)(+0X0123456789.0123456789P-09L));
     ((void)(-0X0123456789.0123456789P-09));
     ((void)(-0X0123456789.0123456789P-09f));
 …
     ((void)(-0X0123456789.0123456789P-09F));
     ((void)(-0X0123456789.0123456789P-09L));
+    ((void)(-0X0123456789.0123456789P-09));
+    ((void)(-0X0123456789.0123456789P-09f));
+    ((void)(-0X0123456789.0123456789P-09l));
+    ((void)(-0X0123456789.0123456789P-09F));
+    ((void)(-0X0123456789.0123456789P-09L));
+    ((void)((signed char )01234567));
+    ((void)((signed short int )01234567));
+    ((void)((signed int )01234567));
+    ((void)((signed long long int )01234567));
+    ((void)((__int128 )01234567));
+    ((void)((unsigned char )01234567u));
+    ((void)((signed short int )01234567u));
+    ((void)((unsigned int )01234567u));
+    ((void)((signed long long int )01234567u));
+    ((void)((__int128 )01234567u));
+    ((void)(+((signed int )((signed char )01234567))));
+    ((void)(+((signed int )((signed short int )01234567))));
+    ((void)(+((signed int )01234567)));
+    ((void)(+((signed long long int )01234567)));
+    ((void)(+((float )((__int128 )01234567))));
+    ((void)(+((signed int )((unsigned char )01234567u))));
+    ((void)(+((signed int )((signed short int )01234567u))));
+    ((void)(+((unsigned int )01234567u)));
+    ((void)(+((signed long long int )01234567u)));
+    ((void)(+((float )((__int128 )01234567u))));
+    ((void)(-((signed int )((signed char )01234567))));
+    ((void)(-((signed int )((signed short int )01234567))));
+    ((void)(-((signed int )01234567)));
+    ((void)(-((signed long long int )01234567)));
+    ((void)(-((float )((__int128 )01234567))));
+    ((void)(-((signed int )((unsigned char )01234567u))));
+    ((void)(-((signed int )((signed short int )01234567u))));
+    ((void)(-((unsigned int )01234567u)));
+    ((void)(-((signed long long int )01234567u)));
+    ((void)(-((float )((__int128 )01234567u))));
+    ((void)((signed char )1234567890));
+    ((void)((signed short int )1234567890));
+    ((void)((signed int )1234567890));
+    ((void)((signed long long int )1234567890));
+    ((void)((__int128 )1234567890));
+    ((void)((signed char )1234567890U));
+    ((void)((unsigned short int )1234567890U));
+    ((void)((signed int )1234567890U));
+    ((void)((unsigned long long int )1234567890u));
+    ((void)((unsigned __int128 )1234567890u));
+    ((void)(+((signed int )((signed char )1234567890))));
+    ((void)(+((signed int )((signed short int )1234567890))));
+    ((void)(+((signed int )1234567890)));
+    ((void)(+((signed long long int )1234567890)));
+    ((void)(+((float )((__int128 )1234567890))));
+    ((void)(+((signed int )((signed char )1234567890U))));
+    ((void)(+((signed int )((unsigned short int )1234567890U))));
+    ((void)(+((signed int )1234567890U)));
+    ((void)(+((unsigned long long int )1234567890u)));
+    ((void)(+((float )((unsigned __int128 )1234567890u))));
+    ((void)(-((signed int )((signed char )1234567890))));
+    ((void)(-((signed int )((signed short int )1234567890))));
+    ((void)(-((signed int )1234567890)));
+    ((void)(-((signed long long int )1234567890)));
+    ((void)(-((float )((__int128 )1234567890))));
+    ((void)(-((signed int )((signed char )1234567890U))));
+    ((void)(-((signed int )((unsigned short int )1234567890U))));
+    ((void)(-((signed int )1234567890U)));
+    ((void)(-((unsigned long long int )1234567890u)));
+    ((void)(-((float )((unsigned __int128 )1234567890u))));
+    ((void)((signed char )0x0123456789abcdef));
+    ((void)((signed short int )0x0123456789abcdef));
+    ((void)((signed int )0x0123456789abcdef));
+    ((void)((signed long long int )0x0123456789abcdef));
+    ((void)((signed char )0x0123456789abcdefu));
+    ((void)((unsigned short int )0x0123456789abcdefu));
+    ((void)((signed int )0x0123456789abcdefu));
+    ((void)((unsigned long long int )0x0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(+((signed int )0x0123456789abcdef)));
+    ((void)(+((signed long long int )0x0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(+((signed int )0x0123456789abcdefu)));
+    ((void)(+((unsigned long long int )0x0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(-((signed int )0x0123456789abcdef)));
+    ((void)(-((signed long long int )0x0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(-((signed int )0x0123456789abcdefu)));
+    ((void)(-((unsigned long long int )0x0123456789abcdefu)));
+    ((void)((signed char )0x0123456789ABCDEF));
+    ((void)((signed short int )0x0123456789ABCDEF));
+    ((void)((signed int )0x0123456789ABCDEF));
+    ((void)((signed long long int )0x0123456789ABCDEF));
+    ((void)((signed char )0x0123456789ABCDEFu));
+    ((void)((unsigned short int )0x0123456789ABCDEFu));
+    ((void)((signed int )0x0123456789ABCDEFu));
+    ((void)((unsigned long long int )0x0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(+((signed int )0x0123456789ABCDEF)));
+    ((void)(+((signed long long int )0x0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )0x0123456789ABCDEFu)));
+    ((void)(+((unsigned long long int )0x0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(-((signed int )0x0123456789ABCDEF)));
+    ((void)(-((signed long long int )0x0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )0x0123456789ABCDEFu)));
+    ((void)(-((unsigned long long int )0x0123456789ABCDEFu)));
+    ((void)((signed char )0X0123456789abcdef));
+    ((void)((signed short int )0X0123456789abcdef));
+    ((void)((signed int )0X0123456789abcdef));
+    ((void)((signed long long int )0X0123456789abcdef));
+    ((void)((signed char )0X0123456789abcdefu));
+    ((void)((unsigned short int )0X0123456789abcdefu));
+    ((void)((signed int )0X0123456789abcdefu));
+    ((void)((unsigned long long int )0X0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(+((signed int )0X0123456789abcdef)));
+    ((void)(+((signed long long int )0X0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(+((signed int )0X0123456789abcdefu)));
+    ((void)(+((unsigned long long int )0X0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(-((signed int )0X0123456789abcdef)));
+    ((void)(-((signed long long int )0X0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(-((signed int )0X0123456789abcdefu)));
+    ((void)(-((unsigned long long int )0X0123456789abcdefu)));
+    ((void)((signed char )0X0123456789ABCDEF));
+    ((void)((signed short int )0X0123456789ABCDEF));
+    ((void)((signed int )0X0123456789ABCDEF));
+    ((void)((signed long long int )0X0123456789ABCDEF));
+    ((void)((signed char )0X0123456789ABCDEFu));
+    ((void)((unsigned short int )0X0123456789ABCDEFu));
+    ((void)((signed int )0X0123456789ABCDEFu));
+    ((void)((unsigned long long int )0X0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(+((signed int )0X0123456789ABCDEF)));
+    ((void)(+((signed long long int )0X0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )0X0123456789ABCDEFu)));
+    ((void)(+((unsigned long long int )0X0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(-((signed int )0X0123456789ABCDEF)));
+    ((void)(-((signed long long int )0X0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )0X0123456789ABCDEFu)));
+    ((void)(-((unsigned long long int )0X0123456789ABCDEFu)));
+    ((void)((float )0123456789.));
+    ((void)((double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)(+((float )0123456789.)));
+    ((void)(+((double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(-((float )0123456789.)));
+    ((void)(-((double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)((float )0123456789.e09));
+    ((void)((double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)(+((float )0123456789.e+09)));
+    ((void)(+((double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(-((float )0123456789.e-09)));
+    ((void)(-((double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)((float ).0123456789e09));
+    ((void)((double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)(+((float ).0123456789E+09)));
+    ((void)(+((double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(-((float ).0123456789E-09)));
+    ((void)(-((double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)((float )0123456789.0123456789));
+    ((void)((double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)(+((float )0123456789.0123456789E09)));
+    ((void)(+((double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(-((float )0123456789.0123456789E+09)));
+    ((void)(-((double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)((float )0123456789.0123456789E-09));
+    ((void)((double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((float )0x0123456789.p09));
+    ((void)((double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)(+((float )0x0123456789.p09)));
+    ((void)(+((double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(-((float )0x0123456789.p09)));
+    ((void)(-((double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)((float )0x0123456789.p+09));
+    ((void)((double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)(+((float )0x0123456789.p-09)));
+    ((void)(+((double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(-((float )0x.0123456789p09)));
+    ((void)(-((double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
     ((void)__f__F_c__1('a'));
     ((void)__f__F_Sc__1(20));
 …
     ((void)L"a" "b" "c");
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/KRfunctions.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
 …
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
 …
     signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ___retval_f10__PFPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{

src/tests/.expect/64/attributes.txt

-              rb96ec83
+              r6840e7c
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 __attribute__ ((unused)) struct Agn1;
 …
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    return ___ret__5sAgn2_1;
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1);
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1);
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1);
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1);
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1);
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object1);
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object2, signed int *__f9__Pi_1);
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
+    return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object3){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object4, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 …
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
 __attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
 signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
 signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned long int )5)]));
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int __ad__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_ad__i_1;
 …
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
+        return ___ret__13s__anonymous4_2;
+    }
     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
 …
+    }
     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
 …
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        return ___ret__13e__anonymous5_2;
+    }
     ((void)sizeof(enum __anonymous5 ));
+}
 signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
 signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
 signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int __anonymous_object28;
     __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned long int )10)];
     __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object32;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
+    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned long int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 …
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object36);
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object37, signed int *__anonymous_object38);
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object39, signed int *__anonymous_object40, signed int __anonymous_object41[((unsigned long int )10)]);
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object42, signed int *__anonymous_object43, signed int __anonymous_object44[((unsigned long int )10)], signed int (*__anonymous_object45)());
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index0 = 0;
+        for (;(_index0<10);((void)(++_index0))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index0)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
+        signed int _index1 = 0;
+        for (;(_index1<10);((void)(++_index1))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index1)])))=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
+        signed int _index2 = (10-1);
+        for (;(_index2>=0);((void)(--_index2))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index2)])))) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
+}
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
+    {
+        signed int _index3 = 0;
+        for (;(_index3<10);((void)(++_index3))) {
+            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index3)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index3)]));
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
+    return ___ret__4sVad_1;
+}
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object46){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index4 = 0;
+        for (;(_index4<10);((void)(++_index4))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index4)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object47, signed int *__anonymous_object48){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
+        signed int _index5 = 0;
+        for (;(_index5<10);((void)(++_index5))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index5)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object49, signed int *__anonymous_object50, signed int __anonymous_object51[((unsigned long int )10)]){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
+        signed int _index6 = 0;
+        for (;(_index6<10);((void)(++_index6))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index6)])))=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object52, signed int *__anonymous_object53, signed int __anonymous_object54[((unsigned long int )10)], signed int (*__anonymous_object55)()){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
+        signed int _index7 = 0;
+        for (;(_index7<10);((void)(++_index7))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)])))=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/64/declarationSpecifier.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__R13s__anonymous1_1)));
+    return ___ret__13s__anonymous1_1;
+}
 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__R13s__anonymous2_1)));
+    return ___ret__13s__anonymous2_1;
+}
 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__R13s__anonymous3_1)));
+    return ___ret__13s__anonymous3_1;
+}
 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__R13s__anonymous4_1)));
+    return ___ret__13s__anonymous4_1;
+}
 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__R13s__anonymous5_1)));
+    return ___ret__13s__anonymous5_1;
+}
 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__R13s__anonymous6_1)));
+    return ___ret__13s__anonymous6_1;
+}
 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__R13s__anonymous7_1)));
+    return ___ret__13s__anonymous7_1;
+}
 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__R13s__anonymous8_1)));
+    return ___ret__13s__anonymous8_1;
+}
 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__R13s__anonymous9_1)));
+    return ___ret__13s__anonymous9_1;
+}
 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__R14s__anonymous10_1)));
+    return ___ret__14s__anonymous10_1;
+}
 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__R14s__anonymous11_1)));
+    return ___ret__14s__anonymous11_1;
+}
 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__R14s__anonymous12_1)));
+    return ___ret__14s__anonymous12_1;
+}
 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__R14s__anonymous13_1)));
+    return ___ret__14s__anonymous13_1;
+}
 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__R14s__anonymous14_1)));
+    return ___ret__14s__anonymous14_1;
+}
 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__R14s__anonymous15_1)));
+    return ___ret__14s__anonymous15_1;
+}
 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__R14s__anonymous16_1)));
+    return ___ret__14s__anonymous16_1;
+}
 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__R14s__anonymous17_1)));
+    return ___ret__14s__anonymous17_1;
+}
 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__R14s__anonymous18_1)));
+    return ___ret__14s__anonymous18_1;
+}
 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__R14s__anonymous19_1)));
+    return ___ret__14s__anonymous19_1;
+}
 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__R14s__anonymous20_1)));
+    return ___ret__14s__anonymous20_1;
+}
 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__R14s__anonymous21_1)));
+    return ___ret__14s__anonymous21_1;
+}
 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__R14s__anonymous22_1)));
+    return ___ret__14s__anonymous22_1;
+}
 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__R14s__anonymous23_1)));
+    return ___ret__14s__anonymous23_1;
+}
 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
 …
     __attribute__ ((unused)) signed int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/extension.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1) /* ?{} */);
 …
     ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
 …
     __extension__ signed int __c__i_1;
 };
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1);
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 …
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__R2uU_1)));
+    return ___ret__2uU_1;
+}
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
+    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
+    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/64/gccExtensions.txt

-              rb96ec83
+              r6840e7c
         ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
 …
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = ((signed int )__extension__ 3);
+    signed int __i__i_2 = __extension__ 3;
     __extension__ signed int __a__i_2;
     __extension__ signed int __b__i_2;
 …
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__R3ss2_2)));
+        return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
 …
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__R3ss3_2)));
+        return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
 …
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__R3ss4_2)));
+        return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
 …
     signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/literals.txt

-              rb96ec83
+              r6840e7c
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1);
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
 …
     struct _Istream_cstrUC ___ret__16s_Istream_cstrUC_1;
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
     ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), ___src__16s_Istream_cstrUC_1));
     return ((struct _Istream_cstrUC )___ret__16s_Istream_cstrUC_1);
+    ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__R16s_Istream_cstrUC_1)));
+    return ___ret__16s_Istream_cstrUC_1;
+}
 static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1){
 …
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1);
 static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
 static inline void ___constructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
 …
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
     ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), ___src__15s_Istream_cstrC_1));
     return ((struct _Istream_cstrC )___ret__15s_Istream_cstrC_1);
+    ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__R15s_Istream_cstrC_1)));
+    return ___ret__15s_Istream_cstrC_1;
+}
 static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1){
 …
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = ((signed int )16),
+    __sepSize__C13e__anonymous0_1 = 16,
 };
 struct ofstream {
 …
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]);
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = ((signed int )0);
+        signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index1 = ((signed int )0);
+    {
+        signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = ((signed int )0);
+        signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)])))=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index3 = ((signed int )0);
+    {
+        signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)])))=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
 …
+    }
+}
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
+    {
         signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)])))) /* ^?{} */);
 …
+    }
+    {
+        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+    {
+        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index5)])))) /* ^?{} */);
 …
+    }
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ^?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         signed int _index6 = ((signed int )0);
+        signed int _index6 = 0;
         for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index6)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index6)]));
 …
+    {
         signed int _index7 = ((signed int )0);
+        signed int _index7 = 0;
         for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index7)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index7)]));
 …
+    }
     ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), ___src__9sofstream_1));
     return ((struct ofstream )___ret__9sofstream_1);
+    ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__R9sofstream_1)));
+    return ___ret__9sofstream_1;
+}
 static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = ((signed int )0);
+        signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index9 = ((signed int )0);
+    {
+        signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = ((signed int )0);
+        signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index11 = ((signed int )0);
+    {
+        signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = ((signed int )0);
+        signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index13 = ((signed int )0);
+    {
+        signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = ((signed int )0);
+        signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index15 = ((signed int )0);
+    {
+        signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = ((signed int )0);
+        signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index17 = ((signed int )0);
+    {
+        signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = ((signed int )0);
+        signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)])))=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index19 = ((signed int )0);
+    {
+        signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = ((signed int )0);
+        signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)])))=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index21 = ((signed int )0);
+    {
+        signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)])))=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
 …
+    }
+}
 _Bool __sepPrt__Fb_P9sofstream__1(struct ofstream *__anonymous_object1294);
 …
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline struct ifstream ___operator_assign__F9sifstream_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1);
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1) /* ?{} */);
 …
     struct ifstream ___ret__9sifstream_1;
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
     ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), ___src__9sifstream_1));
     return ((struct ifstream )___ret__9sifstream_1);
+    ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__R9sifstream_1)));
+    return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
 …
     ((void)0123456789.e-09L);
     ((void)0123456789.e-09DL);
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
     ((void)(-0123456789.e-09l));
     ((void)(-0123456789.e-09F));
     ((void)(-0123456789.e-09L));
     ((void)(-0123456789.e-09DL));
+    ((void)(+0123456789.e-09));
+    ((void)(+0123456789.e-09f));
+    ((void)(+0123456789.e-09l));
+    ((void)(+0123456789.e-09F));
+    ((void)(+0123456789.e-09L));
+    ((void)(+0123456789.e-09DL));
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
 …
     ((void)0123456789.0123456789E-09L);
     ((void)0123456789.0123456789E-09DL);
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
     ((void)(-0123456789.0123456789E-09l));
     ((void)(-0123456789.0123456789E-09F));
     ((void)(-0123456789.0123456789E-09L));
     ((void)(-0123456789.0123456789E-09DL));
+    ((void)(+0123456789.0123456789E-09));
+    ((void)(+0123456789.0123456789E-09f));
+    ((void)(+0123456789.0123456789E-09l));
+    ((void)(+0123456789.0123456789E-09F));
+    ((void)(+0123456789.0123456789E-09L));
+    ((void)(+0123456789.0123456789E-09DL));
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
 …
     ((void)0x0123456789.p-09F);
     ((void)0x0123456789.p-09L);
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
     ((void)(-0x0123456789.p-09l));
     ((void)(-0x0123456789.p-09F));
     ((void)(-0x0123456789.p-09L));
+    ((void)(+0x0123456789.p-09));
+    ((void)(+0x0123456789.p-09f));
+    ((void)(+0x0123456789.p-09l));
+    ((void)(+0x0123456789.p-09F));
+    ((void)(+0x0123456789.p-09L));
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
 …
     ((void)0x.0123456789P-09F);
     ((void)0x.0123456789P-09L);
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
     ((void)(-0x.0123456789P-09l));
     ((void)(-0x.0123456789P-09F));
     ((void)(-0x.0123456789P-09L));
+    ((void)(+0x.0123456789P-09));
+    ((void)(+0x.0123456789P-09f));
+    ((void)(+0x.0123456789P-09l));
+    ((void)(+0x.0123456789P-09F));
+    ((void)(+0x.0123456789P-09L));
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
 …
     ((void)0X0123456789.0123456789P-09F);
     ((void)0X0123456789.0123456789P-09L);
+    ((void)(+0X0123456789.0123456789P-09));
+    ((void)(+0X0123456789.0123456789P-09f));
+    ((void)(+0X0123456789.0123456789P-09l));
+    ((void)(+0X0123456789.0123456789P-09F));
+    ((void)(+0X0123456789.0123456789P-09L));
     ((void)(-0X0123456789.0123456789P-09));
     ((void)(-0X0123456789.0123456789P-09f));
 …
     ((void)(-0X0123456789.0123456789P-09F));
     ((void)(-0X0123456789.0123456789P-09L));
+    ((void)(-0X0123456789.0123456789P-09));
+    ((void)(-0X0123456789.0123456789P-09f));
+    ((void)(-0X0123456789.0123456789P-09l));
+    ((void)(-0X0123456789.0123456789P-09F));
+    ((void)(-0X0123456789.0123456789P-09L));
+    ((void)((signed char )01234567));
+    ((void)((signed short int )01234567));
+    ((void)((signed int )01234567));
+    ((void)((signed long int )01234567));
+    ((void)((__int128 )01234567));
+    ((void)((unsigned char )01234567u));
+    ((void)((signed short int )01234567u));
+    ((void)((unsigned int )01234567u));
+    ((void)((signed long int )01234567u));
+    ((void)((__int128 )01234567u));
+    ((void)(+((signed int )((signed char )01234567))));
+    ((void)(+((signed int )((signed short int )01234567))));
+    ((void)(+((signed int )01234567)));
+    ((void)(+((signed long int )01234567)));
+    ((void)(+((float )((__int128 )01234567))));
+    ((void)(+((signed int )((unsigned char )01234567u))));
+    ((void)(+((signed int )((signed short int )01234567u))));
+    ((void)(+((unsigned int )01234567u)));
+    ((void)(+((signed long int )01234567u)));
+    ((void)(+((float )((__int128 )01234567u))));
+    ((void)(-((signed int )((signed char )01234567))));
+    ((void)(-((signed int )((signed short int )01234567))));
+    ((void)(-((signed int )01234567)));
+    ((void)(-((signed long int )01234567)));
+    ((void)(-((float )((__int128 )01234567))));
+    ((void)(-((signed int )((unsigned char )01234567u))));
+    ((void)(-((signed int )((signed short int )01234567u))));
+    ((void)(-((unsigned int )01234567u)));
+    ((void)(-((signed long int )01234567u)));
+    ((void)(-((float )((__int128 )01234567u))));
+    ((void)((signed char )1234567890));
+    ((void)((signed short int )1234567890));
+    ((void)((signed int )1234567890));
+    ((void)((signed long int )1234567890));
+    ((void)((__int128 )1234567890));
+    ((void)((signed char )1234567890U));
+    ((void)((unsigned short int )1234567890U));
+    ((void)((signed int )1234567890U));
+    ((void)((unsigned long int )1234567890u));
+    ((void)((unsigned __int128 )1234567890u));
+    ((void)(+((signed int )((signed char )1234567890))));
+    ((void)(+((signed int )((signed short int )1234567890))));
+    ((void)(+((signed int )1234567890)));
+    ((void)(+((signed long int )1234567890)));
+    ((void)(+((float )((__int128 )1234567890))));
+    ((void)(+((signed int )((signed char )1234567890U))));
+    ((void)(+((signed int )((unsigned short int )1234567890U))));
+    ((void)(+((signed int )1234567890U)));
+    ((void)(+((unsigned long int )1234567890u)));
+    ((void)(+((float )((unsigned __int128 )1234567890u))));
+    ((void)(-((signed int )((signed char )1234567890))));
+    ((void)(-((signed int )((signed short int )1234567890))));
+    ((void)(-((signed int )1234567890)));
+    ((void)(-((signed long int )1234567890)));
+    ((void)(-((float )((__int128 )1234567890))));
+    ((void)(-((signed int )((signed char )1234567890U))));
+    ((void)(-((signed int )((unsigned short int )1234567890U))));
+    ((void)(-((signed int )1234567890U)));
+    ((void)(-((unsigned long int )1234567890u)));
+    ((void)(-((float )((unsigned __int128 )1234567890u))));
+    ((void)((signed char )0x0123456789abcdef));
+    ((void)((signed short int )0x0123456789abcdef));
+    ((void)((signed int )0x0123456789abcdef));
+    ((void)((signed long int )0x0123456789abcdef));
+    ((void)((signed char )0x0123456789abcdefu));
+    ((void)((unsigned short int )0x0123456789abcdefu));
+    ((void)((signed int )0x0123456789abcdefu));
+    ((void)((unsigned long int )0x0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(+((signed int )0x0123456789abcdef)));
+    ((void)(+((signed long int )0x0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(+((signed int )0x0123456789abcdefu)));
+    ((void)(+((unsigned long int )0x0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(-((signed int )0x0123456789abcdef)));
+    ((void)(-((signed long int )0x0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(-((signed int )0x0123456789abcdefu)));
+    ((void)(-((unsigned long int )0x0123456789abcdefu)));
+    ((void)((signed char )0x0123456789ABCDEF));
+    ((void)((signed short int )0x0123456789ABCDEF));
+    ((void)((signed int )0x0123456789ABCDEF));
+    ((void)((signed long int )0x0123456789ABCDEF));
+    ((void)((signed char )0x0123456789ABCDEFu));
+    ((void)((unsigned short int )0x0123456789ABCDEFu));
+    ((void)((signed int )0x0123456789ABCDEFu));
+    ((void)((unsigned long int )0x0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(+((signed int )0x0123456789ABCDEF)));
+    ((void)(+((signed long int )0x0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )0x0123456789ABCDEFu)));
+    ((void)(+((unsigned long int )0x0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(-((signed int )0x0123456789ABCDEF)));
+    ((void)(-((signed long int )0x0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )0x0123456789ABCDEFu)));
+    ((void)(-((unsigned long int )0x0123456789ABCDEFu)));
+    ((void)((signed char )0X0123456789abcdef));
+    ((void)((signed short int )0X0123456789abcdef));
+    ((void)((signed int )0X0123456789abcdef));
+    ((void)((signed long int )0X0123456789abcdef));
+    ((void)((signed char )0X0123456789abcdefu));
+    ((void)((unsigned short int )0X0123456789abcdefu));
+    ((void)((signed int )0X0123456789abcdefu));
+    ((void)((unsigned long int )0X0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(+((signed int )0X0123456789abcdef)));
+    ((void)(+((signed long int )0X0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(+((signed int )0X0123456789abcdefu)));
+    ((void)(+((unsigned long int )0X0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(-((signed int )0X0123456789abcdef)));
+    ((void)(-((signed long int )0X0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(-((signed int )0X0123456789abcdefu)));
+    ((void)(-((unsigned long int )0X0123456789abcdefu)));
+    ((void)((signed char )0X0123456789ABCDEF));
+    ((void)((signed short int )0X0123456789ABCDEF));
+    ((void)((signed int )0X0123456789ABCDEF));
+    ((void)((signed long int )0X0123456789ABCDEF));
+    ((void)((signed char )0X0123456789ABCDEFu));
+    ((void)((unsigned short int )0X0123456789ABCDEFu));
+    ((void)((signed int )0X0123456789ABCDEFu));
+    ((void)((unsigned long int )0X0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(+((signed int )0X0123456789ABCDEF)));
+    ((void)(+((signed long int )0X0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )0X0123456789ABCDEFu)));
+    ((void)(+((unsigned long int )0X0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(-((signed int )0X0123456789ABCDEF)));
+    ((void)(-((signed long int )0X0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )0X0123456789ABCDEFu)));
+    ((void)(-((unsigned long int )0X0123456789ABCDEFu)));
+    ((void)((float )0123456789.));
+    ((void)((double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)(+((float )0123456789.)));
+    ((void)(+((double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(-((float )0123456789.)));
+    ((void)(-((double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)((float )0123456789.e09));
+    ((void)((double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)(+((float )0123456789.e+09)));
+    ((void)(+((double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(-((float )0123456789.e-09)));
+    ((void)(-((double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)((float ).0123456789e09));
+    ((void)((double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)(+((float ).0123456789E+09)));
+    ((void)(+((double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(-((float ).0123456789E-09)));
+    ((void)(-((double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)((float )0123456789.0123456789));
+    ((void)((double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)(+((float )0123456789.0123456789E09)));
+    ((void)(+((double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(-((float )0123456789.0123456789E+09)));
+    ((void)(-((double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)((float )0123456789.0123456789E-09));
+    ((void)((double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((float )0x0123456789.p09));
+    ((void)((double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)(+((float )0x0123456789.p09)));
+    ((void)(+((double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(-((float )0x0123456789.p09)));
+    ((void)(-((double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)((float )0x0123456789.p+09));
+    ((void)((double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)(+((float )0x0123456789.p-09)));
+    ((void)(+((double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(-((float )0x.0123456789p09)));
+    ((void)(-((double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
     ((void)__f__F_c__1('a'));
     ((void)__f__F_Sc__1(20));
 …
     ((void)L"a" "b" "c");
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/castError.txt

-              rb96ec83
+              r6840e7c
+castError.c:7:1 error: Cannot choose between 3 alternatives for expression Cast of:
+castError.c:7:1 error: Cannot choose between 3 alternatives for expression
+Cast of:
   Name: f
+... to:
+  charAlternatives are:
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: function
+       accepting unspecified arguments
+     ... returning nothing
+to:
+  char
+Alternatives are:        Cost ( 1, 0, 0, 0 ): Cast of:
+          Variable Expression: f: function
+                accepting unspecified arguments
+              returning
+                nothing
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: signed int
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: double
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
-        to:
-          char
-(types:
-            char
+)
-        Environment:
-        Cost ( 1, 0, 0, 0 ): Cast of:
-          Variable Expression: f: signed int
-        to:
-          char
-(types:
-            char
+)
-        Environment:
-        Cost ( 1, 0, 0, 0 ): Cast of:
-          Variable Expression: f: double
-        to:
-          char
-(types:
-            char
+)
-        Environment:

src/tests/.expect/scopeErrors.txt

-              rb96ec83
+              r6840e7c
 scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
 scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
+  with parameters
+    double
+  returning
+    _retval_butThisIsAnError:       Attribute with name: unused
+double
+  with body
+    CompoundStmt
+... with parameters
+  double
+... returning
+  _retval_butThisIsAnError: double
+  ... with attributes:
+    Attribute with name: unused
+... with body
+  CompoundStmt

src/tests/Makefile.am

-              rb96ec83
+              r6840e7c
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Mon Sep 11 16:17:16 2017
 ## Update Count     : 45
+## Last Modified On : Tue Oct 10 14:04:40 2017
+## Update Count     : 47
 ###############################################################################
 …
 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               \
+        fmtLines                \
+        pingpong                \
+        prodcons                \
+        thread                  \
+        matrixSum               \
+        monitor                 \
+        multi-monitor           \
+        boundedBuffer           \
+        preempt                 \
+        sched-int-block         \
+        sched-int-disjoint      \
+        sched-int-wait          \
+        sched-ext-barge         \
+        sched-ext-dtor          \
+        sched-ext-else          \
+        sched-ext-parse         \
+        sched-ext-recurse       \
+        sched-ext-statment      \
+        sched-ext-when
 else
 concurrent=no
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/Makefile.in

-              rb96ec83
+              r6840e7c
 @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 = \
+@BUILD_CONCURRENCY_TRUE@        coroutine               \
+@BUILD_CONCURRENCY_TRUE@        fmtLines                \
+@BUILD_CONCURRENCY_TRUE@        pingpong                \
+@BUILD_CONCURRENCY_TRUE@        prodcons                \
+@BUILD_CONCURRENCY_TRUE@        thread                  \
+@BUILD_CONCURRENCY_TRUE@        matrixSum               \
+@BUILD_CONCURRENCY_TRUE@        monitor                 \
+@BUILD_CONCURRENCY_TRUE@        multi-monitor           \
+@BUILD_CONCURRENCY_TRUE@        boundedBuffer           \
+@BUILD_CONCURRENCY_TRUE@        preempt                 \
+@BUILD_CONCURRENCY_TRUE@        sched-int-block         \
+@BUILD_CONCURRENCY_TRUE@        sched-int-disjoint      \
+@BUILD_CONCURRENCY_TRUE@        sched-int-wait          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-barge         \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-dtor          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-else          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-parse         \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-recurse       \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-statment      \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-when
 # applies to both programs
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/coroutine.c

-              rb96ec83
+              r6840e7c
 // Created On       : Thu Jun  8 07:29:37 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  8 07:37:12 2017
 // Update Count     : 5
+// Last Modified On : Sun Sep 17 21:38:15 2017
+// Update Count     : 7
 //
 …
 coroutine Fibonacci {
         int fn;                                         // used for communication
+        int fn;                                                                                         // used for communication
 };
 …
 void main( Fibonacci & this ) {
         int fn1, fn2;                                   // retained between resumes
         this.fn = 0;                                    // case 0
+        int fn1, fn2;                                                                           // retained between resumes
+        this.fn = 0;                                                                            // case 0
         fn1 = this.fn;
         suspend();                                              // return to last resume
+        suspend();                                                                                      // restart last resume
+        this.fn = 1;                                    // case 1
+        fn2 = fn1;
+        fn1 = this.fn;
+        suspend();                                              // return to last resume
+        this.fn = 1;                                                                            // case 1
+        fn2 = fn1;  fn1 = this.fn;
+        suspend();                                                                                      // restart last resume
         for ( ;; ) {                                    // general case
+        for ( ;; ) {                                                                            // general case
                 this.fn = fn1 + fn2;
+                fn2 = fn1;
+                fn1 = this.fn;
+                suspend();                                      // return to last resume
+                fn2 = fn1;  fn1 = this.fn;
+                suspend();                                                                              // restart last resume
         } // for
+}
 int next( Fibonacci & this ) {
         resume( this );                                 // transfer to last suspend
+        resume( this );                                                                         // restart last suspend
         return this.fn;
+}
 …
         Fibonacci f1, f2;
         for ( int i = 1; i <= 10; i += 1 ) {
                 sout | next( f1 ) | ' ' | next( f2 ) | endl;
+                sout | next( f1 ) | next( f2 ) | endl;
         } // for
+}

src/tests/fmtLines.c

-              rb96ec83
+              r6840e7c
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 18 11:35:57 2017
 // Update Count     : 31
+// Last Modified On : Sun Oct  1 11:57:19 2017
+// Update Count     : 34
 //
 …
 void ?{}( Format & fmt ) {
     resume( fmt );                                                                              // start coroutine
+        resume( fmt );                                                                          // prime (start) coroutine
+}
 void ^?{}( Format & fmt ) {
     if ( fmt.g != 0 || fmt.b != 0 ) sout | endl;
+        if ( fmt.g != 0 || fmt.b != 0 ) sout | endl;
+}
 …
 void prt( Format & fmt, char ch ) {
     fmt.ch = ch;
     resume( fmt );
+        fmt.ch = ch;
+        resume( fmt );
 } // prt
 int main() {
         Format fmt;
+        Format fmt;                                                                                     // format characters into blocks of 4 and groups of 5 blocks per line
         char ch;
         for ( ;; ) {
+        Eof: for ( ;; ) {                                                                       // read until end of file
                 sin | ch;                                                                               // read one character
           if ( eof( sin ) ) break;                                                      // eof ?
                 prt( fmt, ch );
+          if ( eof( sin ) ) break Eof;                                          // eof ?
+                prt( fmt, ch );                                                                 // push character for formatting
         } // for
 } // main

src/tests/gmp.c

-              rb96ec83
+              r6840e7c
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep  4 09:51:18 2017
 // Update Count     : 550
+// Last Modified On : Thu Sep 28 18:33:51 2017
+// Update Count     : 555
 //
 …
         sout | "Factorial Numbers" | endl;
+        Int fact;
+        fact = 1;                                                                                       // 1st case
+        Int fact = 1;                                                                           // 1st case
         sout | (int)0 | fact | endl;
         for ( unsigned int i = 1; i <= 40; i += 1 ) {

src/tests/literals.c

-              rb96ec83
+              r6840e7c
 // Created On       : Sat Sep  9 16:34:38 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 12 07:45:46 2017
 // Update Count     : 88
+// Last Modified On : Mon Sep 25 20:26:00 2017
+// Update Count     : 132
 //
 #ifdef __CFA__
+#include <stdint.h>
 #include <fstream>
 …
          0123456789.e-09;   0123456789.e-09f;   0123456789.e-09l;   0123456789.e-09F;   0123456789.e-09L;   0123456789.e-09DL;
         -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09L;  -0123456789.e-09DL;
+        +0123456789.e-09;  +0123456789.e-09f;  +0123456789.e-09l;  +0123456789.e-09F;  +0123456789.e-09L;  +0123456789.e-09DL;
         -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09L;  -0123456789.e-09DL;
 …
          0123456789.0123456789E-09;   0123456789.0123456789E-09f;   0123456789.0123456789E-09l;   0123456789.0123456789E-09F;   0123456789.0123456789E-09L;   0123456789.0123456789E-09DL;
         -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09L;  -0123456789.0123456789E-09DL;
+        +0123456789.0123456789E-09;  +0123456789.0123456789E-09f;  +0123456789.0123456789E-09l;  +0123456789.0123456789E-09F;  +0123456789.0123456789E-09L;  +0123456789.0123456789E-09DL;
         -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09L;  -0123456789.0123456789E-09DL;
 …
 x0123456789.p-09;   0x0123456789.p-09f;   0x0123456789.p-09l;   0x0123456789.p-09F;   0x0123456789.p-09L;
         -0x0123456789.p-09;  -0x0123456789.p-09f;  -0x0123456789.p-09l;  -0x0123456789.p-09F;  -0x0123456789.p-09L;
+        +0x0123456789.p-09;  +0x0123456789.p-09f;  +0x0123456789.p-09l;  +0x0123456789.p-09F;  +0x0123456789.p-09L;
         -0x0123456789.p-09;  -0x0123456789.p-09f;  -0x0123456789.p-09l;  -0x0123456789.p-09F;  -0x0123456789.p-09L;
 …
 x.0123456789P-09;   0x.0123456789P-09f;   0x.0123456789P-09l;   0x.0123456789P-09F;   0x.0123456789P-09L;
         -0x.0123456789P-09;  -0x.0123456789P-09f;  -0x.0123456789P-09l;  -0x.0123456789P-09F;  -0x.0123456789P-09L;
+        +0x.0123456789P-09;  +0x.0123456789P-09f;  +0x.0123456789P-09l;  +0x.0123456789P-09F;  +0x.0123456789P-09L;
         -0x.0123456789P-09;  -0x.0123456789P-09f;  -0x.0123456789P-09l;  -0x.0123456789P-09F;  -0x.0123456789P-09L;
 …
 X0123456789.0123456789P-09;   0X0123456789.0123456789P-09f;   0X0123456789.0123456789P-09l;   0X0123456789.0123456789P-09F;   0X0123456789.0123456789P-09L;
+        +0X0123456789.0123456789P-09;  +0X0123456789.0123456789P-09f;  +0X0123456789.0123456789P-09l;  +0X0123456789.0123456789P-09F;  +0X0123456789.0123456789P-09L;
         -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
+        -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
+#ifdef __CFA__
+// fixed-size length
+        // octal
+         01234567_l8;   01234567_l16;   01234567_l32;   01234567_l64;   01234567_l128;   01234567_l8u;   01234567_ul16;   01234567_l32u;   01234567_ul64;   01234567_ul128;
+        +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_l128;  +01234567_l8u;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;  +01234567_ul128;
+        -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l128;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;  -01234567_ul128;
+        // decimal
+         1234567890L8;   1234567890L16;   1234567890l32;   1234567890l64;   1234567890l128;   1234567890UL8;   1234567890L16U;   1234567890Ul32;   1234567890l64u;   1234567890l128u;
+        +1234567890L8;  +1234567890L16;  +1234567890l32;  +1234567890l64;  +1234567890l128;  +1234567890UL8;  +1234567890L16U;  +1234567890Ul32;  +1234567890l64u;  +1234567890l128u;
+        -1234567890L8;  -1234567890L16;  -1234567890l32;  -1234567890l64;  -1234567890l128;  -1234567890UL8;  -1234567890L16U;  -1234567890Ul32;  -1234567890l64u;  -1234567890l128u;
+        // hexadecimal
+x0123456789abcdef_l8;   0x0123456789abcdef_l16;   0x0123456789abcdefl32;   0x0123456789abcdefl64;   0x0123456789abcdef_ul8;   0x0123456789abcdef_l16u;   0x0123456789abcdeful32;   0x0123456789abcdefl64u;
+        +0x0123456789abcdef_l8;  +0x0123456789abcdef_l16;  +0x0123456789abcdefl32;  +0x0123456789abcdefl64;  +0x0123456789abcdef_ul8;  +0x0123456789abcdef_l16u;  +0x0123456789abcdeful32;  +0x0123456789abcdefl64u;
+        -0x0123456789abcdef_l8;  -0x0123456789abcdef_l16;  -0x0123456789abcdefl32;  -0x0123456789abcdefl64;  -0x0123456789abcdef_ul8;  -0x0123456789abcdef_l16u;  -0x0123456789abcdeful32;  -0x0123456789abcdefl64u;
+x0123456789ABCDEF_l8;   0x0123456789ABCDEF_l16;   0x0123456789ABCDEFl32;   0x0123456789ABCDEFl64;   0x0123456789ABCDEF_ul8;   0x0123456789ABCDEF_l16u;   0x0123456789ABCDEFul32;   0x0123456789ABCDEFl64u;
+        +0x0123456789ABCDEF_l8;  +0x0123456789ABCDEF_l16;  +0x0123456789ABCDEFl32;  +0x0123456789ABCDEFl64;  +0x0123456789ABCDEF_ul8;  +0x0123456789ABCDEF_l16u;  +0x0123456789ABCDEFul32;  +0x0123456789ABCDEFl64u;
+        -0x0123456789ABCDEF_l8;  -0x0123456789ABCDEF_l16;  -0x0123456789ABCDEFl32;  -0x0123456789ABCDEFl64;  -0x0123456789ABCDEF_ul8;  -0x0123456789ABCDEF_l16u;  -0x0123456789ABCDEFul32;  -0x0123456789ABCDEFl64u;
+X0123456789abcdef_l8;   0X0123456789abcdef_l16;   0X0123456789abcdefl32;   0X0123456789abcdefl64;   0X0123456789abcdef_ul8;   0X0123456789abcdef_l16u;   0X0123456789abcdeful32;   0X0123456789abcdefl64u;
+        +0X0123456789abcdef_l8;  +0X0123456789abcdef_l16;  +0X0123456789abcdefl32;  +0X0123456789abcdefl64;  +0X0123456789abcdef_ul8;  +0X0123456789abcdef_l16u;  +0X0123456789abcdeful32;  +0X0123456789abcdefl64u;
+        -0X0123456789abcdef_l8;  -0X0123456789abcdef_l16;  -0X0123456789abcdefl32;  -0X0123456789abcdefl64;  -0X0123456789abcdef_ul8;  -0X0123456789abcdef_l16u;  -0X0123456789abcdeful32;  -0X0123456789abcdefl64u;
+X0123456789ABCDEF_l8;   0X0123456789ABCDEF_l16;   0X0123456789ABCDEFl32;   0X0123456789ABCDEFl64;   0X0123456789ABCDEF_ul8;   0X0123456789ABCDEF_l16u;   0X0123456789ABCDEFul32;   0X0123456789ABCDEFl64u;
+        +0X0123456789ABCDEF_l8;  +0X0123456789ABCDEF_l16;  +0X0123456789ABCDEFl32;  +0X0123456789ABCDEFl64;  +0X0123456789ABCDEF_ul8;  +0X0123456789ABCDEF_l16u;  +0X0123456789ABCDEFul32;  +0X0123456789ABCDEFl64u;
+        -0X0123456789ABCDEF_l8;  -0X0123456789ABCDEF_l16;  -0X0123456789ABCDEFl32;  -0X0123456789ABCDEFl64;  -0X0123456789ABCDEF_ul8;  -0X0123456789ABCDEF_l16u;  -0X0123456789ABCDEFul32;  -0X0123456789ABCDEFl64u;
+        // floating
+         0123456789.l32;   0123456789.l64;   0123456789.l80;   0123456789.l128;
+        +0123456789.l32;  +0123456789.l64;  +0123456789.l80;  +0123456789.l128;
+        -0123456789.l32;  -0123456789.l64;  -0123456789.l80;  -0123456789.l128;
+         0123456789.e09L32;    0123456789.e09L64;    0123456789.e09L80;    0123456789.e09L128;
+        +0123456789.e+09L32;  +0123456789.e+09L64;  +0123456789.e+09L80;  +0123456789.e+09L128;
+        -0123456789.e-09L32;  -0123456789.e-09L64;  -0123456789.e-09L80;  -0123456789.e-09L128;
+         .0123456789e09L32;    .0123456789e09L64;    .0123456789e09L80;    .0123456789e09L128;
+        +.0123456789E+09L32;  +.0123456789E+09L64;  +.0123456789E+09L80;  +.0123456789E+09L128;
+        -.0123456789E-09L32;  -.0123456789E-09L64;  -.0123456789E-09L80;  -.0123456789E-09L128;
+         0123456789.0123456789L32;       0123456789.0123456789L64;       0123456789.0123456789L80;       0123456789.0123456789L128;
+        +0123456789.0123456789E09L32;   +0123456789.0123456789E09L64;   +0123456789.0123456789E09L80;   +0123456789.0123456789E09L128;
+        -0123456789.0123456789E+09L32;  -0123456789.0123456789E+09L64;  -0123456789.0123456789E+09L80;  -0123456789.0123456789E+09L128;
+         0123456789.0123456789E-09L32;   0123456789.0123456789E-09L64;   0123456789.0123456789E-09L80;   0123456789.0123456789E-09L128;
+x0123456789.p09l32;   0x0123456789.p09l64;   0x0123456789.p09l80;   0x0123456789.p09l128;
+        +0x0123456789.p09l32;  +0x0123456789.p09l64;  +0x0123456789.p09l80;  +0x0123456789.p09l128;
+        -0x0123456789.p09l32;  -0x0123456789.p09l64;  -0x0123456789.p09l80;  -0x0123456789.p09l128;
+x0123456789.p+09l32;   0x0123456789.p+09L64;   0x0123456789.p+09L80;   0x0123456789.p+09L128;
+        +0x0123456789.p-09l32;  +0x0123456789.p-09L64;  +0x0123456789.p-09L80;  +0x0123456789.p-09L128;
+        -0x.0123456789p09l32;   -0x.0123456789p09L64;   -0x.0123456789p09L80;   -0x.0123456789p09L128;
 // char, short, int suffix overloading
-#ifdef __CFA__
         f( 'a' );
         f( 20_hh );

src/tests/sched-ext-parse.c

-              rb96ec83
+              r6840e7c
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
+//
+//              DEPRECATED TEST
+//              DIFFERS BETWEEN DEBUG AND RELEASE
+//
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
 #include <monitor>

src/tests/sched-int-barge.c

-              rb96ec83
+              r6840e7c
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
+//
+//              DEPRECATED TEST
+//
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
 #include <fstream>
 #include <kernel>

src/tests/sched-int-block.c

-              rb96ec83
+              r6840e7c
+//---------------------------------------------------------
+// Barging test
+// Ensures that no barging can occur between :
+//   - the frontend of the signal_block and the signaled thread
+//   - the signaled  threadand the backend of the signal_block
+//---------------------------------------------------------
 #include <fstream>
 #include <kernel>

src/tests/sched-int-wait.c

-              rb96ec83
+              r6840e7c
+//---------------------------------------------------------
+// Multi wait test
+// Ensures that no deadlock from waiting/signalling conditions
+//---------------------------------------------------------
 #include <fstream>
 #include <kernel>

Context Navigation

Legend: