Diff [1f44196dc72fd060b6183fe2bdc10f7b30f955d6:3a2128f5aaa77a03c76ff6198907b91256d8c603] for / – Cforall

doc/proposals/concurrency/Makefile

r1f44196	r3a2128f
9	9	SOURCES = ${addsuffix .tex, \
10	10	concurrency \
11		~~style \~~
12		~~glossary \~~
13	11	}
14	12

doc/proposals/concurrency/concurrency.tex

-              r1f44196
+              r3a2128f
 % Latex packages used in the document.
 \usepackage[T1]{fontenc}                                        % allow Latin1 (extended ASCII) characters
+\usepackage[T1]{fontenc}                                % allow Latin1 (extended ASCII) characters
 \usepackage{textcomp}
 \usepackage[latin1]{inputenc}
 \usepackage{fullpage,times,comment}
 \usepackage{epic,eepic}
 \usepackage{upquote}                                            % switch curled `'" to straight
+\usepackage{upquote}                                                                    % switch curled `'" to straight
 \usepackage{calc}
 \usepackage{xspace}
 …
 \usepackage{tabularx}
 \usepackage[acronym]{glossaries}
 \usepackage{varioref}                                           % extended references
+\usepackage{varioref}                                                           % extended references
 \usepackage{inconsolata}
 \usepackage{listings}                                           % format program code
 \usepackage[flushmargin]{footmisc}                              % support label/reference in footnote
 \usepackage{latexsym}                                           % \Box glyph
 \usepackage{mathptmx}                                           % better math font with "times"
+\usepackage{listings}                                                                   % format program code
+\usepackage[flushmargin]{footmisc}                                              % support label/reference in footnote
+\usepackage{latexsym}                                   % \Box glyph
+\usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
 \usepackage[pagewise]{lineno}
 \usepackage{fancyhdr}
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
 \input{style}                                                   % bespoke macros used in the document
+\input{common}                                          % bespoke macros used in the document
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 \usepackage{breakurl}
 …
 \renewcommand{\UrlFont}{\small\sf}
 \setlength{\topmargin}{-0.45in}                         % move running title into header
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
 \setlength{\headsep}{0.25in}
 …
 \title{Concurrency in \CFA}
 \author{Thierry Delisle \\
 School of Computer Science, University of Waterloo, \\ Waterloo, Ontario, Canada
+Dept. of Computer Science, University of Waterloo, \\ Waterloo, Ontario, Canada
+}
 …
 \section{Introduction}
+This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible concurrency core 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.
+There are actually two problems that need to be solved in the design of the concurrency for a programming language: which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are more about performance, cost and resource utilization.
+This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible core 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 construct 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 parallelism, message passing, implicit threading.
+There are actually two problems that need to be solved in the design of the concurrency for a language. Which concurrency tools are available to the users and which parallelism tools are available. While these two concepts are often seen together, they are in fact distinct concepts that require different sorts of tools\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization while parallelism tools are more about performance, cost and resource utilization.
 %  #####  ####### #     #  #####  #     # ######  ######  ####### #     #  #####  #     #
 …
 \section{Concurrency}
+Several tool can be used to solve concurrency challenges. Since these challenges always 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). Which in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. This distinction can be hidden away in library code, but 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 objects. At a lower level these can be implemented as locks and atomic operations. 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 add such a paradigm to a language like C or \CC\cit, 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.
+% Several tool can be used to solve concurrency challenges. Since these challenges always 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 rely on message passing or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. However, for productivity reasons it is desireable to have a higher-level construct to be the core concurrency paradigm\cite{HPP:Study}. This project proposes Monitors\cite{Hoare74} as the core concurrency construct.
+% \\
+Several tool can be used to solve concurrency challenges. Since these challenges always 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 rely on message passing\cite{Thoth,Harmony,V-Kernel} or other paradigms that often closely relate to networking concepts. However, in imperative or OO languages, these approaches entail a clear distinction between concurrent and non-concurrent paradigms (i.e. message passing versus routine call). Which in turns mean that programmers need to learn two sets of designs patterns in order to be effective. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on non-concurrent constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. 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 to be the core concurrency paradigm\cite{HPP:Study}. 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.
+\\
+Finally, an approach that is worth mentionning because it is gaining in popularity is transactionnal memory\cite{Dice10}. However, the performance and feature set is currently too restrictive to be possible to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA.
 % #     # ####### #     # ### ####### ####### ######   #####
 …
 \subsection{Monitors}
 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 OOP semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it :
+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 OOP 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{lstlisting}
         typedef /*some monitor type*/ monitor;
 …
 \subsubsection{Call semantics} \label{call}
+The above monitor example displays some of the intrinsic characteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual-exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
+Another aspect to consider is when a monitor acquires its mutual exclusion. For example, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual-exclusion on entry. Pass through can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following to implement an atomic counter :
+\begin{lstlisting}
+        mutex struct 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 here
+        void ?{}(size_t * this, counter_t & mutex cnt); //conversion
+\end{lstlisting}
+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} key word depending on whether or not reading an \code{size_t} is an atomic operation or not.
+Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without wualifiers \code{void foo(counter_t & this)} then one could argue that it should default to the safest option \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that \code{nomutex} is the more "normal" behaviour, the \code{nomutex} keyword effectively stating explicitly that "this routine has nothing 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 routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach is used for clarity.
+The next semantic decision is to establish when mutex/nomutex may be used as a type qualifier. Consider the following declarations:
+The above example of monitors already displays some of their intrinsic caracteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
+\\
+Another aspect to consider is when a monitor acquires its mutual exclusion. Indeed, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual exclusion on entry. Examples of this can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following example :
+\begin{lstlisting}
+        mutex struct counter_t { /*...*/ };
+        void ?{}(counter_t & nomutex this);
+        int ++?(counter_t & mutex this);
+        void ?{}(Int * this, counter_t & mutex cnt);
+\end{lstlisting}
+*semantics of the declaration of \code{mutex struct counter_t} are discussed in details in section \ref{data}
+\\
+This example is of a monitor implementing an atomic counter. Here, the constructor uses the \code{nomutex} keyword to signify that it does not acquire the coroutine mutual exclusion when constructing. This is because object not yet constructed should never be shared and therefore do not require mutual exclusion. The prefix increment operator
+uses \code{mutex} to protect the incrementing process from race conditions. Finally, we have a conversion operator from \code{counter_t} to \code{Int}. This conversion may or may not require the \code{mutex} key word depending whether or not reading an \code{Int} is an atomic operation or not.
+\\
+Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. If there were a meaning to routine \code{void foo(counter_t & this)} then one could argue that it should be to default to the safest option : \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that this is the more "normal" behavior, \code{nomutex} effectively stating explicitly that "this routine has nothing special". An other alternative is to make one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being more clearly self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach will be used for the sake of clarity.
+\\
+Regardless of which keyword is kept, it is important to establish when mutex/nomutex may be used depending on type parameters.
 \begin{lstlisting}
         int f1(monitor & mutex m);
 …
         int f5(graph(monitor*) & mutex m);
 \end{lstlisting}
+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 we only acquire objects once becomes also 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 (ignoring potential qualifiers and indirections). 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, it would also be reasonnable to disallow mutex in the context where arrays may be passed.
+The problem is to indentify which object(s) should be acquired. Furthermore we also need to acquire each objects only once. In case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entering. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object will be acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths aren't necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5} which uses a custom 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 (ignoring potential qualifiers and indirections).
 % ######     #    #######    #
 …
 \subsubsection{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 contian 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}:
+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 contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appripriate protection. For example here is a more fleshed-out version of the counter showed in \ref{call}:
 \begin{lstlisting}
         mutex struct counter_t {
 …
         int ++?(counter_t & mutex this) {
+                return ++this.value;
+        }
+        //need for mutex is platform dependent here
+                return ++this->value;
+        }
         void ?{}(int * this, counter_t & mutex cnt) {
                 *this = (int)cnt;
+        }
 \end{lstlisting}
+This simple counter is used as follows:
+\begin{center}
+\begin{tabular}{c @{\hskip 0.35in} c @{\hskip 0.35in} c}
+\begin{lstlisting}
+        //shared counter
+        counter_t cnt;
+        //multiple threads access counter
+        thread 1 : cnt++;
+        thread 2 : cnt++;
+        thread 3 : cnt++;
+          ...
+        thread N : cnt++;
+\begin{tabular}{ c c }
+Thread 1 & Thread 2 \\
+\begin{lstlisting}
+        void f(counter_t & mutex c) {
+                for(;;) {
+                        sout | (int)c | endl;
+                }
+        }
+\end{lstlisting} &\begin{lstlisting}
+        void g(counter_t & mutex c) {
+                for(;;) {
+                        ++c;
+                }
+        }
 \end{lstlisting}
 \end{tabular}
+\end{center}
+Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. 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 to multi-monitor calls.
+\\
+This simple counter offers an example of monitor usage. Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. \\
+These simple mutual exclusion semantics also naturally expand to multi-monitor calls.
 \begin{lstlisting}
         int f(MonitorA & mutex a, MonitorB & mutex b);
 …
         f(a,b);
 \end{lstlisting}
+This code acquires both locks before entering the critical section, 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{lstlisting}
+        void foo(A & mutex a, B & mutex b) { //acquire a & b
+This code acquires both locks before entering the critical section. In practice, writing multi-locking routines that can not lead to deadlocks can be very tricky. Having language level support for such feature is therefore a significant asset for \CFA. However, this does have significant repercussions relating to scheduling (see \ref{insched} and \ref{extsched}). Furthermore, the ability to acquire multiple monitors at the same time does incur a significant pitfall even without looking into scheduling. For example :
+\begin{lstlisting}
+        void foo(A & mutex a, B & mutex a) {
                 //...
+        }
         void bar(A & mutex a, B & nomutex b) { //acquire a
+        void bar(A & mutex a, B & nomutex a)
                 //...
                 foo(a, b); //acquire b
+                foo(a, b);
                 //...
+        }
         void baz(A & nomutex a, B & mutex b) { //acquire b
+        void baz(A & nomutex a, B & mutex a)
                 //...
                 foo(a, b); //acquire a
+                foo(a, b);
                 //...
+        }
 \end{lstlisting}
+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. such use leads to nested monitor call problems~\cite{Lister77}, which is a specific implementation of 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.
+Recursive mutex routine calls are allowed in \CFA but if not done carefully it can lead to nested monitor call problems\cite{Lister77}. These problems which are a specific  implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{bar} but explicit ordering in the case of \code{baz}. This subtle mistake can mean that calling these two functions concurrently will lead to deadlocks, depending on the implicit ordering matching the explicit ordering. As shown on several occasion\cit, there isn't really any solutions to this problem, users simply need to be carefull when acquiring multiple monitors at the same time.
 % ######  ####### #######    #    ### #        #####
 …
 \subsubsection{Implementation Details: Interaction with polymorphism}
+At first glance, interaction between monitors and \CFA's concept of polymorphism seems complex to support. However, it is shown that entry-point locking can solve most of the issues.
+Before looking into complex control flow, it is important to present the difference between the two acquiring options : \gls{callsite-locking} and \gls{entry-point-locking}, i.e. acquiring the monitors before making a mutex call or as the first instruction of the mutex call. For example:
+\begin{center}
+\begin{tabular}{|c|c|c|}
+Code & \gls{callsite-locking} & \gls{entry-point-locking} \\
+\CFA & pseudo-code & pseudo-code \\
+\hline
+\begin{lstlisting}
+void foo(monitor & mutex a) {
+        //Do Work
+        //...
+}
+void main() {
+        monitor a;
+        foo(a);
+}
+\end{lstlisting} &\begin{lstlisting}
+foo(& a) {
+        //Do Work
+        //...
+}
+main() {
+        monitor a;
+        //calling routine
+        //handles concurrency
+        acquire(a);
+        foo(a);
+        release(a);
+}
+\end{lstlisting} &\begin{lstlisting}
+foo(& a) {
+        //called routine
+        //handles concurrency
+        acquire(a);
+        //Do Work
+        //...
+        release(a);
+}
+main() {
+        monitor a;
+        foo(a);
+}
+\end{lstlisting}
+\end{tabular}
+\end{center}
+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. \Gls{callsite-locking} would require a significant amount of work, 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.
+At first glance, interaction between monitors and \CFA's concept of polymorphism seem complexe to support. However, it can be reasoned that entry-point locking can solve most of the issues that could be present with polymorphism.
+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. We must remember that monitors' 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 handle incomplete types (by definition) no \code{dtype} polymorphic routine can access shared data since the data would require knowledge about the type. Therefore the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. With callsite-locking, this would require significant amount of work since any \code{dtype} routine could have to obtain some lock before calling a routine. However, with entry-point-locking calling a monitor routine becomes exactly the same as calling it from anywhere else.
 % ### #     # #######         #####   #####  #     # ####### ######
 …
 \subsection{Internal scheduling} \label{insched}
 Monitors also need to schedule waiting threads internally as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and have threads wait and signaled from them. Here is a simple example of such a technique :
+Monitors should also be able to schedule what threads access it as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and wait for them to be signaled. Here is a simple example of such a technique :
 \begin{lstlisting}
 …
 \end{lstlisting}
+Note that 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. This semantic can easily be extended to multi-monitor calls by offering the same guarantee.
+Here routine \code{foo} waits on the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. This semantic can easily be extended to multi-monitor calls by offering the same guarantee.
 \begin{center}
 \begin{tabular}{ c @{\hskip 0.65in} c }
 …
 \begin{lstlisting}
 void foo(monitor & mutex a,
            monitor & mutex b) {
+         monitor & mutex b) {
         //...
         wait(a.e);
 …
 \end{lstlisting} &\begin{lstlisting}
 void bar(monitor & mutex a,
            monitor & mutex b) {
+         monitor & mutex b) {
         signal(a.e);
+}
 …
 \end{tabular}
 \end{center}
+A direct extension of the single monitor semantics is to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. It is possible to support internal scheduling and \gls{group-acquire} without any extra syntax by relying on order of acquisition. Here is an example of the different contexts in which internal scheduling can be used. (Note that here the use of helper routines is irrelevant, only routines acquire mutual exclusion have an impact on internal scheduling):
+A direct extension of the single monitor semantics would be to release all locks when waiting and transferring ownership of all locks when signalling. However, for the purpose of synchronization it may be usefull to only release some of the locks but keep others. On the technical side, partially releasing lock is feasible but from the user perspective a choice must be made for the syntax of this feature. It is possible to do without any extra syntax by relying on order of acquisition (Note that here the use of helper routines is irrelevant, only routines the acquire mutual exclusion have an impact on internal scheduling):
 \begin{center}
 …
 condition e;
-//acquire a & b
 void foo(monitor & mutex a,
+           monitor & mutex b) {
+        wait(e); //release a & b
+         monitor & mutex b) {
+        wait(e);
+}
 …
 condition e;
-//acquire a
 void bar(monitor & mutex a,
            monitor & nomutex b) {
+         monitor & nomutex b) {
         foo(a,b);
+}
-//acquire a & b
 void foo(monitor & mutex a,
            monitor & mutex b) {
         wait(e);  //release a & b
+         monitor & mutex b) {
+        wait(e);
+}
 …
 condition e;
-//acquire a
 void bar(monitor & mutex a,
+           monitor & nomutex b) {
+        baz(a,b);
+}
+//acquire b
+         monitor & nomutex b) {
+        foo(a,b);
+}
 void baz(monitor & nomutex a,
            monitor & mutex b) {
         wait(e);  //release b
+         monitor & mutex b) {
+        wait(e);
+}
 …
 \end{center}
+Context 1 is the simplest way of acquiring more than one monitor (\gls{group-acquire}), using a routine with multiple parameters having the \code{mutex} keyword. Context 2 also uses \gls{group-acquire} as well in routine \code{foo}. However, the routine is called by routine \code{bar}, which only acquires monitor \code{a}. Since monitors can be acquired multiple times this does not cause a deadlock by itself but it does force the acquiring order to \code{a} then \code{b}. Context 3 also forces the acquiring order to be \code{a} then \code{b} but does not use \gls{group-acquire}. The previous example tries to illustrate the semantics that must be established to support releasing monitors in a \code{wait} statement. In all cases, the behavior of the wait statment is to release all the locks that were acquired my the inner-most monitor call. That is \code{a & b} in context 1 and 2 and \code{b} only in context 3. Here are a few other examples of this behavior.
+This can be interpreted in two different ways :
+\begin{flushleft}
+\begin{enumerate}
+        \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{ignoring} nested calls.
+        \item \code{wait} atomically releases the monitors acquired by the inner-most routine, \underline{considering} nested calls.
+\end{enumerate}
+\end{flushleft}
+While the difference between these two is subtle, it has a significant impact. In the first case it means that the calls to \code{foo} would behave the same in Context 1 and 2. This semantic would also mean that the call to \code{wait} in routine \code{baz} would only release \code{monitor b}. While this may seem intuitive with these examples, it does have one significant implication, it creates a strong distinction between acquiring multiple monitors in sequence and acquiring the same monitors simulatenously, i.e. :
+\begin{center}
+\begin{tabular}{c @{\hskip 0.35in} c @{\hskip 0.35in} c}
+\begin{lstlisting}
+enterMonitor(a);
+enterMonitor(b);
+// do stuff
+leaveMonitor(b);
+leaveMonitor(a);
+\end{lstlisting} & != &\begin{lstlisting}
+enterMonitor(a);
+enterMonitor(a, b);
+// do stuff
+leaveMonitor(a, b);
+leaveMonitor(a);
+\end{lstlisting}
+\end{tabular}
+\end{center}
+This is not intuitive because even if both methods display the same monitors state both inside and outside the critical section respectively, the behavior is different. Furthermore, the actual acquiring order will be exaclty the same since acquiring a monitor from inside its mutual exclusion is a no-op. This means that even if the data and the actual control flow are the same using both methods, the behavior of the \code{wait} will be different. The alternative is option 2, that is releasing acquired monitors, \underline{considering} nesting. This solves the issue of having the two acquiring method differ at the cost of making routine \code{foo} behave differently depending on from which context it is called (Context 1 or 2). Indeed in Context 2, routine \code{foo} actually behaves like routine \code{baz} rather than having the same behavior than in Context 1. The fact that both implicit approaches can be unintuitive depending on the perspective may be a sign that the explicit approach is superior. For this reason this \CFA does not support implicit monitor releasing and uses explicit semantics.
+\\
+The following examples shows three alternatives of explicit wait semantics :
+\\
 \begin{center}
 \begin{tabular}{|c|c|c|}
+\begin{lstlisting}
+condition e;
+//acquire b
+void foo(monitor & nomutex a,
+           monitor & mutex b) {
+        bar(a,b);
+}
+//acquire a
+void bar(monitor & mutex a,
+           monitor & nomutex b) {
+        wait(e); //release a
+                  //keep b
+}
+foo(a, b);
+Case 1 & Case 2 & Case 3 \\
+Branding on construction & Explicit release list & Explicit ignore list \\
+\hline
+\begin{lstlisting}
+void foo(monitor & mutex a,
+         monitor & mutex b,
+           condition & c)
+{
+        // Releases monitors
+        // branded in ctor
+        wait(c);
+}
+monitor a;
+monitor b;
+condition1 c1 = {a};
+condition2 c2 = {a, b};
+//Will release only a
+foo(a,b,c1);
+//Will release a and b
+foo(a,b,c2);
 \end{lstlisting} &\begin{lstlisting}
-condition e;
-//acquire a & b
 void foo(monitor & mutex a,
+           monitor & mutex b) {
+        bar(a,b);
+}
+//acquire b
+void bar(monitor & mutex a,
+           monitor & nomutex b) {
+        wait(e); //release b
+                  //keep a
+}
+foo(a, b);
+         monitor & mutex b,
+           condition & c)
+{
+        // Releases monitor a
+        // Holds monitor b
+        waitRelease(c, [a]);
+}
+monitor a;
+monitor b;
+condition c;
+foo(a,b,c);
 \end{lstlisting} &\begin{lstlisting}
-condition e;
-//acquire a & b
 void foo(monitor & mutex a,
+           monitor & mutex b) {
+        bar(a,b);
+}
+//acquire none
+void bar(monitor & nomutex a,
+           monitor & nomutex b) {
+        wait(e); //release a & b
+                  //keep none
+}
+foo(a, b);
+         monitor & mutex b,
+           condition & c)
+{
+        // Releases monitor a
+        // Holds monitor b
+        waitHold(c, [b]);
+}
+monitor a;
+monitor b;
+condition c;
+foo(a,b,c);
 \end{lstlisting}
 \end{tabular}
 \end{center}
+Note the right-most example is actually a trick pulled on the reader. Monitor state information is stored in thread local storage rather then in the routine context, which means that helper routines and other \code{nomutex} routines are invisible to the runtime system in regards to concurrency. This means that in the right-most example, the routine parameters are completly unnecessary. However, calling this routine from outside a valid monitor context is undefined.
+These semantics imply that in order to release of subset of the monitors currently held, users must write (and name) a routine that only acquires the desired subset and simply calls wait. While users can use this method, \CFA offers the \code{wait_release}\footnote{Not sure if an overload of \code{wait} would work...} which will release only the specified monitors. In the center previous examples, the code in the center uses the \code{bar} routine to only release monitor \code{b}. Using the \code{wait_release} helper, this can be rewritten without having the name two routines :
+\begin{center}
+\begin{tabular}{ c c c }
+\begin{lstlisting}
+        condition e;
+        //acquire a & b
+        void foo(monitor & mutex a,
+                   monitor & mutex b) {
+                bar(a,b);
+        }
+        //acquire b
+        void bar(monitor & mutex a,
+                   monitor & nomutex b) {
+                wait(e); //release b
+                          //keep a
+        }
+        foo(a, b);
+\end{lstlisting} &\begin{lstlisting}
+        =>
+\end{lstlisting} &\begin{lstlisting}
+        condition e;
+        //acquire a & b
+        void foo(monitor & mutex a,
+                   monitor & mutex b) {
+                wait_release(e,b); //release b
+                                         //keep a
+        }
+        foo(a, b);
+\end{lstlisting}
+\end{tabular}
+\end{center}
+Regardless of the context in which the \code{wait} statement is used, \code{signal} must be called holding the same set of monitors. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
+Finally, an additional semantic which can be very usefull is the \code{signal_block} routine. This routine behaves like signal for all of the semantics discussed above, but with the subtelty that mutual exclusion is transferred to the waiting task immediately rather than wating for the end of the critical section.
+(Note : Case 2 and 3 use tuple semantics to pass a variable length list of elements.)
+\\
+All these cases have their pros and cons. Case 1 is more distinct because it means programmers need to be carefull about where the condition is initialized as well as where it is used. On the other hand, it is very clear and explicitly states which monitor is released and which monitor stays acquired. This is similar to Case 2, which releases only the monitors explictly listed. However, in Case 2, calling the \code{wait} routine instead of the \code{waitRelease} routine releases all the acquired monitor. The Case 3 is an improvement on that since it releases all the monitors except those specified. The result is that the \code{wait} routine can be written as follows :
+\begin{lstlisting}
+void wait(condition & cond) {
+        waitHold(cond, []);
+}
+\end{lstlisting}
+This alternative offers nice and consistent behavior between \code{wait} and \code{waitHold}. However, one large pitfall is that mutual exclusion can now be violated by calls to library code. Indeed, even if the following example seems benign there is one significant problem :
+\begin{lstlisting}
+monitor global;
+extern void doStuff(); //uses global
+void foo(monitor & mutex m) {
+        //...
+        doStuff(); //warning can release monitor m
+        //...
+}
+foo(global);
+\end{lstlisting}
+Indeed, if Case 2 or 3 are chosen it any code can violate the mutual exclusion of the calling code by issuing calls to \code{wait} or \code{waitHold} in a nested monitor context. Case 2 can be salvaged by removing the \code{wait} routine from the API but Case 3 cannot prevent users from calling \code{waitHold(someCondition, [])}. For this reason the syntax proposed in Case 3 is rejected. Note that the syntax proposed in case 1 and 2 are not exclusive. Indeed, by supporting two types of condition both cases can be supported :
+\begin{lstlisting}
+struct condition { /*...*/ };
+// Second argument is a variable length tuple.
+void wait(condition & cond, [...] monitorsToRelease);
+void signal(condition & cond);
+struct conditionN { /*...*/ };
+void ?{}(conditionN* this, /*list of N monitors to release*/);
+void wait(conditionN & cond);
+void signal(conditionN & cond);
+\end{lstlisting}
+Regardless of the option chosen for wait semantics, signal must be symmetrical. In all cases, signal only needs a single parameter, the condition variable that needs to be signalled. But \code{signal} needs to be called from the same monitor(s) that call to \code{wait}. Otherwise, mutual exclusion cannot be properly transferred back to the waiting monitor.
+Finally, an additionnal semantic which can be very usefull is the \code{signalBlock} routine. This routine behaves like signal for all of the semantics discussed above, but with the subtelty that mutual exclusion is transferred to the waiting task immediately rather than wating for the end of the critical section.
 \\
 …
 % #        #   #     #    ###    #     # #     # #     # #       #     #
 % ####### #     #    #    ###     #####   #####  #     # ####### ######
+\newpage
 \subsection{External scheduling} \label{extsched}
 An alternative to internal scheduling is to use external scheduling instead. 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 (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where 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 following example shows a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
+As one might expect, the alternative to Internal scheduling is to use External scheduling instead. This method is somewhat more robust to deadlocks since one of the threads keeps a relatively tight control on scheduling. Indeed, as the following examples will demonstrate, 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 (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where 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 following example shows what a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
 \begin{center}
 …
         public:
                 void f() { /*...*/ }
+                void f();
                 void g() { _Accept(f); }
         private:
 …
 \end{center}
 In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} is the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
+In the case of internal scheduling, the call to \code{wait} only guarantees that \code{g} was the last routine to access the monitor. This intails that the routine \code{f} may have acquired mutual exclusion several times while routine \code{h} was waiting. On the other hand, external scheduling guarantees that while routine \code{h} was waiting, no routine other than \code{g} could acquire the monitor.
 \\
 …
 % #       #     # #     # #     # ####### ####### ####### ####### ###  #####  #     #
 \section{Parallelism}
 Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being a direct consequence of speed increase, parallelism has become the new source for increased performance~\cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create a high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest-level approach of parallelism is to use \glspl{kthread} in combination with semantics like \code{fork}, \code{join}, etc. However, since these have significant costs and limitations, \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues that all have strengths and weaknesses. While there are many variations of the presented paradigms, most of these variations do not actually change the guarantees or the semantics, they simply move costs in order to achieve better performance for certain workloads.
+Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being an ever growing challenge, parallelism has become the new source of greatest performance \cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest level approach of parallelism is to use \glspl{kthread}. However since these have significant costs and limitations \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues which all have strengths and weaknesses.
 \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.
+Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
+\subsubsection{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.
+An example of a language that uses fibers is Go~\cite{Go}
+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 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 complexities are hidden, users still have to think about data races, deadlocks and synchronization issues. This 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 are Java\cite{Java}, Haskell\cite{Haskell} and \uC\cite{uC++book}.
 \subsection{Jobs and thread pools}
+The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
+The gold standard of this implementation is Intel's TBB library~\cite{TBB}.
+The approach on the opposite end of the spectrum is to base parallelism on \glspl{job}. Indeed, \glspl{job} offer limited flexibility but at the benefit of a simpler user interface. In \gls{job} based systems users express parallelism as units of work and the dependency graph (either explicit or implicit) that tie them together. This means users need not to worry about concurrency but significantly limits the interaction that can occur between different jobs. Indeed, any \gls{job} that blocks also blocks the underlying \gls{kthread}, this effectively mean the CPU utilization, and therefore throughput, will suffer noticeably.
+The golden standard of this implementation is Intel's TBB library\cite{TBB}.
+\subsection{Fibers : user-level threads without preemption}
+Finally, in the middle of the flexibility versus complexity spectrum lay \glspl{fiber} which offer \glspl{uthread} without the complexity of preemption. This means users don't have to worry about other \glspl{fiber} suddenly executing between two instructions which signficantly reduces complexity. However, any call to IO or other concurrency primitives can lead to context switches. Furthermore, users can also block \glspl{fiber} in the middle of their execution without blocking a full processor core. This means users still have to worry about mutual exclusion, deadlocks and race conditions in their code, raising the complexity significantly.
+An example of a language that uses fibers is Go\cite{Go}
 \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 pin the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms will show better performance but it all strongly depends on the usage. Having mostly indepent units of work to execute almost guarantess that the \gls{job} based system will have the best performance. However, add interactions between jobs and the processor utilisation might suffer. User-level threads may allow maximum ressource utilisation but context switches will be more expansive and it is also harder for users to get perfect tunning. As with every example, fibers sit somewhat in the middle of the spectrum. Furthermore, if the units of uninterrupted work are large enough the paradigm choice will be largely amorticised by the actual work done.
 %  #####  #######    #          ####### ######  ######
 …
 \section{\CFA 's Thread Building Blocks}
+As a system-level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, deconstructing popular paradigms in order to get simple building blocks yields \glspl{uthread} as the core parallelism block. \Glspl{pool} and other parallelism paradigms can then be built on top of the underlying threading model.
+As a system level language, \CFA should offer both performance and flexibilty as its primary goals, simplicity and user-friendliness being a secondary concern. Therefore, the core of parallelism in \CFA should prioritize power and efficiency. With this said, it is possible to deconstruct the three paradigms details aboved in order to get simple building blocks. Here is a table showing the core caracteristics of the mentionned paradigms :
+\begin{center}
+\begin{tabular}[t]{| r | c | c |}
+\cline{2-3}
+\multicolumn{1}{ c| }{} & Has a stack & Preemptive \\
+\hline
+\Glspl{job} & X & X \\
+\hline
+\Glspl{fiber} & \checkmark & X \\
+\hline
+\Glspl{uthread} & \checkmark & \checkmark \\
+\hline
+\end{tabular}
+\end{center}
+As shown in section \ref{cfaparadigms} these different blocks being available in \CFA it is trivial to reproduce any of these paradigm.
 % ####### #     # ######  #######    #    ######   #####
 …
 \subsection{Thread Interface}
 The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread}, and as such, offer a flexible and lightweight threading interface (lightweight compared to \glspl{kthread}). A thread can be declared using a struct declaration with prefix \code{thread} as follows :
+The basic building blocks of \CFA are \glspl{cfathread}. By default these are implemented as \glspl{uthread} and as such offer a flexible and lightweight threading interface (lightweight comparatievely to \glspl{kthread}). A thread can be declared using a struct declaration prefix with the \code{thread} as follows :
 \begin{lstlisting}
 …
 \end{lstlisting}
 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), the existing syntax for declaring routines names with special semantics can be extended, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as :
+Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use some function pointer representation as the interface of threads (for example : \Csharp \cite{Csharp} and Scala \cite{Scala}). However, we consider that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is definetely a special routine in \CFA, we can reuse the existing syntax for declaring routines with unordinary name, i.e. operator overloading. As such the \code{main} routine of a thread can be defined as such :
 \begin{lstlisting}
         thread struct foo {};
         void ?main(foo* this) {
                 sout | "Hello World!" | endl;
+        }
 \end{lstlisting}
 In this example, threads of type \code{foo} will start there execution in the \code{void ?main(foo*)} routine which in this case prints \code{"Hello World!"}. While this proposoal encourages this approach which is enforces strongly type 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 :
+        void ?main(thread foo* this) {
+                /*... Some useful code ...*/
+        }
+\end{lstlisting}
+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{lstlisting}
         typedef void (*voidFunc)(void);
 …
         //ctor
         void ?{}(FuncRunner* this, voidFunc inFunc) {
+        void ?{}(thread FuncRunner* this, voidFunc inFunc) {
                 func = inFunc;
+        }
         //main
         void ?main(FuncRunner* this) {
+        void ?main(thread FuncRunner* this) {
                 this->func();
+        }
 \end{lstlisting}
+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.
+\begin{lstlisting}
+thread struct World; //FuncRunner declared above
+void ?main(thread World* this) {
+% In this example \code{func} is a function pointer stored in \acrfull{tls}, which is \CFA is both easy to use and completly typesafe.
+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 not needed. 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.
+\begin{lstlisting}
+thread struct FuncRunner; //FuncRunner declared above
+void world() {
         sout | "World!" | endl;
+}
 void main() {
         World w;
+        FuncRunner run = {world};
         //Thread run forks here
 …
+}
 \end{lstlisting}
+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. 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. While this seems like a significant limitation, existing \CFA semantics can solve this problem. Indeed, by using dynamic allocation to create threads will naturally let threads outlive the scope in which the thread was created much like dynamically allocating memory will let objects outlive the scope in which thy were created :
+This semantic has several advantages over explicit semantics : typesafety is guaranteed, any thread will always be started and stopped exaclty once and users can't make any progamming errors. Furthermore it naturally follows the memory allocation semantics which means users don't need to learn multiple semantics.
+These semantics also naturally scale to multiple threads meaning basic synchronisation is very simple :
 \begin{lstlisting}
         thread struct MyThread {
 …
         //ctor
+        void ?{}(MyThread* this,
+                     bool is_special = false) {
+                //...
+        }
+        void ?{}(thread MyThread* this) {}
         //main
+        void ?main(MyThread* this) {
+                //...
+        }
+        void foo() {
+                MyThread* special_thread;
+                {
+                        MyThread thrds = {false};
+                        //Start a thread at the beginning of the scope
+                        DoStuff();
+                        //create a other thread that will outlive the thread in this scope
+                        special_thread = new MyThread{true};
+                        //Wait for the thread to finish
+                }
+                DoMoreStuff();
+                //Now wait for the special
+        }
+\end{lstlisting}
+Another advantage of this semantic is that it naturally scale to multiple threads meaning basic synchronisation is very simple :
+\begin{lstlisting}
+        thread struct MyThread {
+                //...
+        };
+        //ctor
+        void ?{}(MyThread* this) {}
+        //main
+        void ?main(MyThread* this) {
+        void ?main(thread MyThread* this) {
                 //...
+        }
 …
 \end{lstlisting}
-\subsection{Coroutines : A stepping stone}\label{coroutine}
-While the main focus of this proposal is concurrency and paralellism, it is important to adress coroutines which are actually a significant underlying aspect of the concurrency system. Indeed, while having nothing todo with parallelism and arguably very little to do with concurrency, coroutines need to deal with context-switchs and 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.
-The core API of coroutines revolve around two features : independent stacks and suspedn/resume. Much like threads the syntax for declaring a coroutine is declaring a type and a main routine for it to start :
-\begin{lstlisting}
-        coroutine struct MyCoroutine {
-                //...
-        };
-        //ctor
-        void ?{}(MyCoroutine* this) {
+        }
-        //main
-        void ?main(MyCoroutine* this) {
-                sout | "Hello World!" | endl;
+        }
-\end{lstlisting}
-One a coroutine is created, users can context switch to it using \code{suspend} and come back using \code{resume}. Here is an example of a solution to the fibonnaci problem using coroutines :
-\begin{lstlisting}
-        coroutine struct Fibonacci {
-                int fn; // used for communication
-        };
-        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
+                }
+        }
-        int next(Fibonacci& this) {
-                resume(&this); // transfer to last suspend
-                return this.fn;
+        }
-        void main() {
-                Fibonacci f1, f2;
-                for ( int i = 1; i <= 10; i += 1 ) {
-                        sout | next(f1) | '§\verb+ +§' | next(f2) | endl;
+                }
+        }
-\end{lstlisting}
 \newpage
 \bf{WORK IN PROGRESS}
+\large{\textbf{WORK IN PROGRESS}}
 \subsection{The \CFA Kernel : Processors, Clusters and Threads}\label{kernel}

doc/proposals/concurrency/glossary.tex

-              r1f44196
+              r3a2128f
 \makeglossaries
-\longnewglossaryentry{callsite-locking}
-{name={callsite-locking}}
+{
-Locking done by the calling routine. With this technique, a routine calling a monitor routine will aquire the monitor \emph{before} making the call to the actuall routine.
+}
-\longnewglossaryentry{entry-point-locking}
-{name={entry-point-locking}}
+{
-Locking done by the called routine. With this technique, a monitor routine called by another routine will aquire the monitor \emph{after} entering the routine body but prior to any other code.
+}
-\longnewglossaryentry{group-acquire}
-{name={bulked acquiring}}
+{
-Implicitly acquiring several monitors when entering a monitor.
+}
 \longnewglossaryentry{uthread}
 {name={user-level thread}}
 …
 \textit{Synonyms : Tasks.}
+}
-\longnewglossaryentry{pool}
-{name={thread-pool}}
+{
-Group of homogeneuous threads that loop executing units of works after another.
-\textit{Synonyms : }
+}

doc/proposals/concurrency/version

r1f44196	r3a2128f
1		0.~~7.48~~
	1	0.4.99

doc/working/resolver_design.md

-              r1f44196
+              r3a2128f
 hypothesis needs to be empirically validated.
-Another approach would be to abandon expression-tree ordering for
-subexpression matching, and order by "most constrained symbol"; symbols would
-be more constrained if there were fewer matching declarations, fewer
-subexpressions yet to resolve, or possibly fewer possible types the expression
-could resolve to. Ordering the expressions in a priority-queue by this metric
-would not necessarily produce a top-down or a bottom-up order, but would add
-opportunities for pruning based on memoized upper and lower bounds.
 Both Baker and Cormack explicitly generate all possible interpretations of a
 given expression; thinking of the set of interpretations of an expression as a

src/CodeGen/CodeGenerator.cc

-              r1f44196
+              r3a2128f
                                                 } else {
                                                         // no address-of operator, so must be a pointer - add dereference
-                                                        // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared.
-                                                        // Since its arguments are modified here, this assertion most commonly triggers when the application
-                                                        // is visited multiple times.
                                                         UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
+                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
+                                                        assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." );
+                                                        newExpr->set_result( type->clone() );
+                                                        assert( (*arg)->get_results().size() == 1 );
+                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
+                                                        assert( type );
+                                                        newExpr->get_results().push_back( type->clone() );
                                                         *arg = newExpr;
                                                 } // if
 …
                 extension( castExpr );
                 output << "(";
                 if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         output << "(void)" ;
                 } else if ( ! castExpr->get_result()->get_isLvalue() ) {
+                } else if ( ! castExpr->get_results().front()->get_isLvalue() ) {
                         // at least one result type of cast, but not an lvalue
                         output << "(";
                         output << genType( castExpr->get_result(), "" );
+                        output << genType( castExpr->get_results().front(), "" );
                         output << ")";
                 } else {
 …
+        }
         void CodeGenerator::visit( TupleExpr * tupleExpr ) { assert( false ); }
+        void CodeGenerator::visit( TupleExpr * tupleExpr ) {}
         void CodeGenerator::visit( TypeExpr * typeExpr ) {}
 …
                 asmExpr->get_operand()->accept( *this );
                 output << " )";
+        }
-        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
-                assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
-                output << "(" << genType( compLitExpr->get_type(), "" ) << ")";
-                compLitExpr->get_initializer()->accept( *this );
+        }
-        void CodeGenerator::visit( StmtExpr * stmtExpr ) {
-                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
-                output << "({" << std::endl;
-                cur_indent += CodeGenerator::tabsize;
-                unsigned int numStmts = stmts.size();
-                unsigned int i = 0;
-                for ( Statement * stmt : stmts ) {
-                        output << indent << printLabels( stmt->get_labels() );
-                        if ( i+1 == numStmts ) {
-                                // last statement in a statement expression needs to be handled specially -
-                                // cannot cast to void, otherwise the expression statement has no value
-                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-                                        exprStmt->get_expr()->accept( *this );
-                                        output << ";" << endl;
-                                        ++i;
-                                        break;
+                                }
+                        }
-                        stmt->accept( *this );
-                        output << endl;
-                        if ( wantSpacing( stmt ) ) {
-                                output << endl;
-                        } // if
-                        ++i;
+                }
-                cur_indent -= CodeGenerator::tabsize;
-                output << indent << "})";
+        }

src/CodeGen/CodeGenerator.h

-              r1f44196
+              r3a2128f
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
-                virtual void visit( CompoundLiteralExpr *compLitExpr );
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr * );
-                virtual void visit( StmtExpr * );
                 //*** Statements

src/CodeGen/GenType.cc

-              r1f44196
+              r3a2128f
                         typeString = "_Atomic " + typeString;
                 } // if
+                if ( type->get_isAttribute() ) {
+                        typeString = "__attribute(( )) " + typeString;
+                } // if
+        }
 } // namespace CodeGen

src/Common/utility.h

-              r1f44196
+              r3a2128f
+}
-// replace element of list with all elements of another list
 template< typename T >
 void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
 …
         return;
+}
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
+}

src/ControlStruct/Mutate.cc

-              r1f44196
+              r3a2128f
 #include "MLEMutator.h"
 #include "ForExprMutator.h"
+#include "LabelTypeChecker.h"
 //#include "ExceptMutator.h"
 …
                 //ExceptMutator exc;
+                // LabelTypeChecker lbl;
                 mutateAll( translationUnit, formut );
                 acceptAll( translationUnit, lfix );
                 //mutateAll( translationUnit, exc );
+                //acceptAll( translationUnit, lbl );
+        }
 } // namespace CodeGen

src/ControlStruct/module.mk

-              r1f44196
+              r3a2128f
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
         ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc \
+        ControlStruct/ForExprMutator.cc
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc

src/GenPoly/Box.cc

-              r1f44196
+              r3a2128f
                         void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
                         void findTypeOps( const Type::ForallList &forall );
+                        void findTypeOps( const std::list< TypeDecl *> &forall );
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
                         FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
 …
+                }
                 void Pass1::findTypeOps( const Type::ForallList &forall ) {
+                void Pass1::findTypeOps( const std::list< TypeDecl *> &forall ) {
                         // what if a nested function uses an assignment operator?
                         // assignOps.clear();
                         for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+                        for ( std::list< TypeDecl *>::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                                 for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         std::string typeName;
 …
                                 std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                                 std::list< FunctionType *> functions;
                                 for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                                for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                         for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
 …
                         // add size/align for generic types to parameter list
                         if ( ! appExpr->get_function()->has_result() ) return;
                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
+                        if ( appExpr->get_function()->get_results().empty() ) return;
+                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
                         assert( funcType );
 …
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
                                 VariableExpr *fnArgBase = getBaseVar( *fnArg );
                                 if ( ! fnArgBase ) continue; // xxx - previously had check for non-empty fnArgBase results
                                 passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_result(), arg, exprTyVars, seenTypes );
+                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
+                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
+                        }
+                }
 …
                         Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
                         appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
                         appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
+                        appExpr->set_function( new NameExpr( adapterName ) );
                         return ret;
 …
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
                         assert( arg->has_result() );
+                        assert( ! arg->get_results().empty() );
                         if ( isPolyType( param, exprTyVars ) ) {
                                 if ( isPolyType( arg->get_result() ) ) {
+                                if ( isPolyType( arg->get_results().front() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_isLvalue() ) {
+                                } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
                                         // xxx - need to test that this code is still reachable
 …
                 void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
                         std::list< Expression *>::iterator cur = arg;
                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                         InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
 …
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
                                         deref->set_result( arg->get_type()->clone() );
+                                        deref->get_results().push_back( arg->get_type()->clone() );
                                         return deref;
                                 } // if
 …
                         Statement *bodyStmt;
                         Type::ForallList::iterator tyArg = realType->get_forall().begin();
                         Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
                         Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
+                        std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
+                        std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
+                        std::list< TypeDecl *>::iterator realTyParam = adaptee->get_forall().begin();
                         for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
                                 assert( tyArg != realType->get_forall().end() );
 …
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                         std::list< FunctionType *> functions;
                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                         findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
 …
                         } // if
                         addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
                         addAssign->set_result( appExpr->get_result()->clone() );
+                        addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
                                 addAssign->set_env( appExpr->get_env() );
 …
                                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                                         if ( varExpr->get_var()->get_name() == "?[?]" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
                                                 Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
                                                 UntypedExpr *ret = 0;
 …
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
                                                         ret->set_result( appExpr->get_result()->clone() );
+                                                        ret->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "*?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( isPolyType( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         Expression *ret = appExpr->get_args().front();
                                                         delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
+                                                        delete ret->get_results().front();
+                                                        ret->get_results().front() = appExpr->get_results().front()->clone();
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
                                                         Type *tempType = appExpr->get_result()->clone();
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
+                                                        Type *tempType = appExpr->get_results().front()->clone();
                                                         if ( env ) {
                                                                 env->apply( tempType );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
                                                 Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 if ( baseType1 && baseType2 ) {
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
                                                         divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
                                                         divide->set_result( appExpr->get_result()->clone() );
+                                                        divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 divide->set_env( appExpr->get_env() );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
+                                                Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env );
                                                 if ( baseType ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
 …
                         useRetval = oldUseRetval;
+                        assert( appExpr->get_function()->has_result() );
+                        PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
+                        FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( ! appExpr->get_function()->get_results().empty() );
+                        PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( function );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
                         if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                        if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                         if ( name->get_name() == "*?" ) {
 …
                 Expression *Pass1::mutate( AddressExpr *addrExpr ) {
                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        assert( ! addrExpr->get_arg()->get_results().empty() );
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
                                 if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), 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() );
+                                                                PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
+                                                                FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( ! appExpr->get_function()->get_results().empty() );
+                                                                PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                                                                assert( pointer );
+                                                                FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
                                 delete ret->get_result();
                                 ret->set_result( addrExpr->get_result()->clone() );
+                                delete ret->get_results().front();
+                                ret->get_results().front() = addrExpr->get_results().front()->clone();
                                 addrExpr->set_arg( 0 );
                                 delete addrExpr;
 …
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
                                 assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                assert( ! returnStmt->get_expr()->get_results().empty() );
                                 // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
                                 // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
 …
                                         // find each of its needed secondary assignment operators
                                         std::list< Expression* > &tyParams = refType->get_parameters();
                                         Type::ForallList &forallParams = functionDecl->get_type()->get_forall();
+                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
                                         std::list< Expression* >::const_iterator tyIt = tyParams.begin();
                                         Type::ForallList::const_iterator forallIt = forallParams.begin();
+                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
                                         for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
                                                 // Add appropriate mapping to assignment expression environment
 …
                                 // replace return statement with appropriate assignment to out parameter
                                 Expression *retParm = new NameExpr( retval->get_name() );
                                 retParm->set_result( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
+                                retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
                                 assignExpr->get_args().push_back( retParm );
                                 assignExpr->get_args().push_back( returnStmt->get_expr() );
 …
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
                         for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
+                        for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
                                 // add all size and alignment parameters to parameter list

src/GenPoly/CopyParams.cc

r1f44196	r3a2128f
54	54	std::map< std::string, DeclarationWithType* > assignOps;
55	55	// assume the assignment operator is the first assert param after any "type" parameter
56		for ( ~~Type::ForallList~~::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {
	56	for ( std::list< TypeDecl* >::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {
57	57	if ( (*tyVar)->get_kind() == TypeDecl::Any ) {
58	58	assert( !(*tyVar)->get_assertions().empty() );

src/GenPoly/FindFunction.cc

-              r1f44196
+              r3a2128f
                 virtual Type *mutate( PointerType *pointerType );
           private:
                 void handleForall( const Type::ForallList &forall );
+                void handleForall( const std::list< TypeDecl* > &forall );
                 std::list< FunctionType* > &functions;
 …
+        }
         void FindFunction::handleForall( const Type::ForallList &forall ) {
                 for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+        void FindFunction::handleForall( const std::list< TypeDecl* > &forall ) {
+                for ( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
                         if ( var != tyVars.end() ) {

src/GenPoly/GenPoly.cc

-              r1f44196
+              r3a2128f
         ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
                 if ( function->get_returnVals().empty() ) return 0;
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
+        }
 …
 //              } // if
                 if ( isDynRet( adaptee, tyVars ) ) return true;
                 for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
 //                      if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
 …
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
                 for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
                         assert( *tyVar );
                         tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();

src/GenPoly/Lvalue.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // Lvalue.cc --
+// Lvalue.cc --
 //
 // Author           : Richard C. Bilson
 …
                   public:
                         Pass1();
                         virtual Expression *mutate( ApplicationExpr *appExpr );
                         virtual Statement *mutate( ReturnStmt *appExpr );
 …
                   private:
                 };
-                /// GCC-like Generalized Lvalues (which have since been removed from GCC)
-                /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues
-                /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c)
-                class GeneralizedLvalue : public Mutator {
-                        typedef Mutator Parent;
-                        virtual Expression * mutate( AddressExpr * addressExpr );
-                };
         } // namespace
 …
                 Pass1 p1;
                 Pass2 p2;
-                GeneralizedLvalue genLval;
                 mutateAll( translationUnit, p1 );
                 acceptAll( translationUnit, p2 );
-                mutateAll( translationUnit, genLval );
+        }
 …
                         appExpr->get_function()->acceptMutator( *this );
                         mutateAll( appExpr->get_args(), *this );
+                        assert( ! appExpr->get_function()->get_results().empty() );
+                        PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                        PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                        assert( function );
                         Type *funType = isLvalueRet( function );
                         if ( funType && ! isIntrinsicApp( appExpr ) ) {
                                 Expression *expr = appExpr;
                                 Type *appType = appExpr->get_result();
+                                Type *appType = appExpr->get_results().front();
                                 if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
                                         // make sure cast for polymorphic type is inside dereference
 …
+                                }
                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                 deref->set_result( appType->clone() );
                                 appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
+                                deref->get_results().push_back( appType->clone() );
+                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
                                 deref->get_args().push_back( expr );
                                 return deref;
 …
                 Statement * Pass1::mutate(ReturnStmt *retStmt) {
                         if ( retval && retStmt->get_expr() ) {
+                                if ( retStmt->get_expr()->get_result()->get_isLvalue() ) {
+                                assert( ! retStmt->get_expr()->get_results().empty() );
+                                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
                                         // ***** Code Removal ***** because casts may be stripped already
 …
                                 retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
                         } // if
                         Visitor::visit( funType );
+                }
-                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
-                                Expression * arg1 = commaExpr->get_arg1()->clone();
-                                Expression * arg2 = commaExpr->get_arg2()->clone();
-                                delete addrExpr;
-                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
-                                Expression * arg1 = condExpr->get_arg1()->clone();
-                                Expression * arg2 = condExpr->get_arg2()->clone();
-                                Expression * arg3 = condExpr->get_arg3()->clone();
-                                delete addrExpr;
-                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+                        }
-                        return addrExpr;
+                }
         } // namespace

src/GenPoly/Specialize.cc

-              r1f44196
+              r3a2128f
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
+                assert( ! actual->get_results().empty() ); // using front, should have this assert
+                if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
                         FunctionType *funType;
                         if ( ( funType = getFunctionType( formalType ) ) ) {
 …
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
                 assert( appExpr->get_function()->has_result() );
                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( ! appExpr->get_function()->get_results().empty() );
+                FunctionType *function = getFunctionType( appExpr->get_function()->get_results().front() );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
 …
         Expression * Specialize::mutate( AddressExpr *addrExpr ) {
                 addrExpr->get_arg()->acceptMutator( *this );
                 assert( addrExpr->has_result() );
                 addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                assert( ! addrExpr->get_results().empty() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_results().front(), addrExpr->get_arg() ) );
                 return addrExpr;
+        }
 …
         Expression * Specialize::mutate( CastExpr *castExpr ) {
                 castExpr->get_arg()->acceptMutator( *this );
                 if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
+                }
                 Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = doSpecialization( castExpr->get_results().front(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast

src/InitTweak/FixInit.cc

-              r1f44196
+              r3a2128f
 #include <iterator>
 #include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
 #include "InitTweak.h"
 #include "FixInit.h"
 …
 #include "GenPoly/DeclMutator.h"
 #include "SynTree/AddStmtVisitor.h"
 #include "CodeGen/GenType.h"  // for warning/error messages
 bool ctordtorp = false; // print all debug
 bool ctorp = false; // print ctor debug
 bool cpctorp = false; // print copy ctor debug
 bool dtorp = false; // print dtor debug
+#include "CodeGen/GenType.h"  // for warnings
+bool ctordtorp = false;
+bool ctorp = false;
+bool cpctorp = false;
+bool dtorp = false;
 #define PRINT( text ) if ( ctordtorp ) { text }
 #define CP_CTOR_PRINT( text ) if ( ctordtorp || cpctorp ) { text }
 …
 namespace InitTweak {
         namespace {
+                const std::list<Label> noLabels;
+                const std::list<Expression*> noDesignators;
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
                 public:
 …
                         static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
+                        typedef SymTab::Indexer Parent;
+                        using Parent::visit;
+                        using SymTab::Indexer::visit;
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr );
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
+                        Expression * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
+                        Expression * makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg = NULL );
+                        ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
                         /// true if type does not need to be copy constructed to ensure correctness
+                        bool skipCopyConstruct( Type * type );
+                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        bool skipCopyConstruct( Type * );
                 private:
                         TypeSubstitution * env;
 …
                         using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
                 };
 …
+                }
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
+                ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
                         assert( var );
-                        return makeCtorDtor( fname, new AddressExpr( new VariableExpr( var ) ), cpArg );
+                }
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg ) {
-                        assert( thisArg );
                         UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
                         untyped->get_args().push_back( thisArg );
+                        untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
                         if (cpArg) untyped->get_args().push_back( cpArg->clone() );
 …
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
+                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
+                        assert( resolved );
+                        ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
                         if ( resolved->get_env() ) {
                                 env->add( *resolved->get_env() );
                         } // if
+                        assert( resolved );
                         delete untyped;
                         return resolved;
+                }
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
+                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
+                        assert( arg->has_result() );
+                        Type * result = arg->get_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
+                        result = result->clone();
+                        impCpCtorExpr->get_env()->apply( result );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                        tmp->get_type()->set_isConst( false );
+                        // create and resolve copy constructor
+                        CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
+                        Expression * cpCtor = makeCtorDtor( "?{}", tmp, arg );
+                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( cpCtor ) ) {
+                        static UniqueName retNamer("_tmp_cp_ret");
+                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
+                        Visitor::visit( impCpCtorExpr );
+                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
+                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        // take each argument and attempt to copy construct it.
+                        for ( Expression * & arg : appExpr->get_args() ) {
+                                CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
+                                // xxx - need to handle tuple arguments
+                                assert( ! arg->get_results().empty() );
+                                Type * result = arg->get_results().front();
+                                if ( skipCopyConstruct( result ) ) continue; // skip certain non-copyable types
+                                // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                                result = result->clone();
+                                impCpCtorExpr->get_env()->apply( result );
+                                ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                tmp->get_type()->set_isConst( false );
+                                // create and resolve copy constructor
+                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
+                                ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
                                 // 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() );
+                                VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() );
                                 assert( function );
+                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) 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 ) );
+                }
+                void ResolveCopyCtors::destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( ret ) ) );
+                }
+                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
+                        Parent::visit( impCpCtorExpr );
+                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
+                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        // take each argument and attempt to copy construct it.
+                        for ( Expression * & arg : appExpr->get_args() ) {
+                                copyConstructArg( arg, impCpCtorExpr );
+                                if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) {
+                                        // 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 ) );
+                                } // if
                         } // for
 …
                         // level. Trying to pass that environment along.
                         callExpr->set_env( impCpCtorExpr->get_env()->clone() );
+                        Type * result = appExpr->get_result();
+                        if ( ! result->isVoid() ) {
+                                static UniqueName retNamer("_tmp_cp_ret");
+                        for ( Type * result : appExpr->get_results() ) {
                                 result = result->clone();
                                 impCpCtorExpr->get_env()->apply( result );
 …
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
+                                if ( ! result->get_isLvalue() ) {
+                                        // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        destructRet( new VariableExpr( ret ), impCpCtorExpr );
+                                }
+                                impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
+                }
-                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
-                        static std::unordered_set< int > vars;
-                        if ( vars.count( unqExpr->get_id() ) ) {
-                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
-                                return;
+                        }
-                        Parent::visit( unqExpr );
-                        // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
-                        assert( unqExpr->get_result() );
-                        if ( ImplicitCopyCtorExpr * impCpCtorExpr = dynamic_cast<ImplicitCopyCtorExpr*>( unqExpr->get_expr() ) ) {
-                                // note the variable used as the result from the call
-                                assert( impCpCtorExpr->get_result() && impCpCtorExpr->get_returnDecls().size() == 1 );
-                                unqExpr->set_var( new VariableExpr( impCpCtorExpr->get_returnDecls().front() ) );
-                        } else {
-                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
-                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
+                        }
-                        vars.insert( unqExpr->get_id() );
+                }
 …
                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
                                 // add that onto the assignment expression so that later steps have the necessary information
                                 assign->set_result( returnDecl->get_type()->clone() );
+                                assign->add_result( returnDecl->get_type()->clone() );
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 if ( callExpr->get_result()->get_isLvalue() ) {
+                                if ( callExpr->get_results().front()->get_isLvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
 …
                                         // an AddressExpr.  Effectively, this turns
                                         //   lvalue T f();
                                         //   &*f();
+                                        //   &*f()
                                         // into
-                                        //   T * f();
                                         //   T * tmp_cp_retN;
                                         //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
+                                        //   tmp_cp_ret_N = &*(tmp_cp_ret_N = &*f(), tmp_cp_ret);
                                         // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
                                         assign->get_args().back() = new AddressExpr( assign->get_args().back() );
+                                        Type * resultType = returnDecl->get_type()->clone();
                                         returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
+                                        retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
+                                        retExpr = UntypedExpr::createDeref( retExpr );
+                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->get_args().push_back( retExpr );
+                                        deref->add_result( resultType );
+                                        retExpr = deref;
                                 } // if
                                 retExpr->set_env( env->clone() );
 …
                                 return callExpr;
                         } // if
+                }
-                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
-                        static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
-                        // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
-                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
-                        if ( unqMap.count( unqExpr->get_id() ) ) {
-                                // take data from other UniqueExpr to ensure consistency
-                                delete unqExpr->get_expr();
-                                unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
-                                delete unqExpr->get_result();
-                                unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
-                                if ( addDeref.count( unqExpr->get_id() ) ) {
-                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
-                                        return UntypedExpr::createDeref( unqExpr );
+                                }
-                                return unqExpr;
+                        }
-                        unqMap[unqExpr->get_id()] = unqExpr;
-                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
-                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
-                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
-                                // (i.e. move the dereference out a level)
-                                assert( getFunctionName( deref ) == "*?" );
-                                unqExpr->set_expr( getCallArg( deref, 0 ) );
-                                getCallArg( deref, 0 ) = unqExpr;
-                                addDeref.insert( unqExpr->get_id() );
-                                return deref;
+                        }
-                        return unqExpr;
+                }
 …
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
+                        // xxx - is the size check necessary?
+                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        assert( ctorExpr->get_results().size() == 1 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
                         addDeclaration( tmp );
 …
                         assign->get_args().push_back( new VariableExpr( tmp ) );
                         assign->get_args().push_back( firstArg );
                         assign->set_result( ctorExpr->get_result()->clone() );
+                        cloneAll( ctorExpr->get_results(), assign->get_results() );
                         firstArg = assign;

src/InitTweak/GenInit.cc

-              r1f44196
+              r3a2128f
 #include "GenPoly/DeclMutator.h"
 #include "GenPoly/ScopedSet.h"
-#include "ResolvExpr/typeops.h"
 namespace InitTweak {
 …
           protected:
                 FunctionType * ftype;
+                std::list<DeclarationWithType*> returnVals;
                 UniqueName tempNamer;
                 std::string funcName;
 …
                 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;
 …
         Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
+                // update for multiple return values
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
 …
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
+                // xxx - need to handle named return values - this pass may need to happen
+                // after resolution? the ordering is tricky because return statements must be
+                // constructed - the simplest way to do that (while also handling multiple
+                // returns) is to structure the returnVals into a tuple, as done here.
+                // however, if the tuple return value is structured before resolution,
+                // it's difficult to resolve named return values, since the name is lost
+                // in conversion to a tuple. this might be easiest to deal with
+                // after reference types are added, as it may then be possible to
+                // uniformly move named return values to the parameter list directly
+                ValueGuard< FunctionType * > oldFtype( ftype );
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
                 ValueGuard< std::string > oldFuncName( funcName );
+                ftype = functionDecl->get_functionType();
+                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
+                if ( retVals.size() > 1 ) {
+                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
+                        ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        retVals.clear();
+                        retVals.push_back( newRet );
+                }
+                FunctionType * type = functionDecl->get_functionType();
+                returnVals = type->get_returnVals();
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
 …
+        }
-        bool CtorDtor::isManaged( Type * type ) const {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
-                        // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
-                                return true;
+                        }
+                }
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
+        }
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
 …
                         type = at->get_base();
+                }
                 return isManaged( type );
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
+        }
 …
                         managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
+                }
+        }
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl ) {
-                // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
-                // for each constructable object
-                std::list< Statement * > ctor;
-                std::list< Statement * > dtor;
-                InitExpander srcParam( objDecl->get_init() );
-                InitExpander nullParam( (Initializer *)NULL );
-                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
-                // Currently genImplicitCall produces a single Statement - a CompoundStmt
-                // which  wraps everything that needs to happen. As such, it's technically
-                // possible to use a Statement ** in the above calls, but this is inherently
-                // unsafe, so instead we take the slightly less efficient route, but will be
-                // immediately informed if somehow the above assumption is broken. In this case,
-                // we could always wrap the list of statements at this point with a CompoundStmt,
-                // but it seems reasonable at the moment for this to be done by genImplicitCall
-                // itself. It is possible that genImplicitCall produces no statements (e.g. if
-                // an array type does not have a dimension). In this case, it's fine to ignore
-                // the object for the purposes of construction.
-                assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
-                if ( ctor.size() == 1 ) {
-                        // need to remember init expression, in case no ctors exist
-                        // if ctor does exist, want to use ctor expression instead of init
-                        // push this decision to the resolver
-                        assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
-                        return new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() );
+                }
-                return nullptr;
+        }
 …
                         if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
+                        objDecl->set_init( genCtorInit( objDecl ) );
+                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
+                        // for each constructable object
+                        std::list< Statement * > ctor;
+                        std::list< Statement * > dtor;
+                        InitExpander srcParam( objDecl->get_init() );
+                        InitExpander nullParam( (Initializer *)NULL );
+                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
+                        // which  wraps everything that needs to happen. As such, it's technically
+                        // possible to use a Statement ** in the above calls, but this is inherently
+                        // unsafe, so instead we take the slightly less efficient route, but will be
+                        // immediately informed if somehow the above assumption is broken. In this case,
+                        // we could always wrap the list of statements at this point with a CompoundStmt,
+                        // but it seems reasonable at the moment for this to be done by genImplicitCall
+                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
+                        // an array type does not have a dimension). In this case, it's fine to ignore
+                        // the object for the purposes of construction.
+                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
+                        if ( ctor.size() == 1 ) {
+                                // need to remember init expression, in case no ctors exist
+                                // if ctor does exist, want to use ctor expression instead of init
+                                // push this decision to the resolver
+                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
+                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
+                        }
+                }
                 return Parent::mutate( objDecl );
 …
                 managedTypes.beginScope();
                 // go through assertions and recursively add seen ctor/dtors
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 assertion = assertion->acceptMutator( *this );

src/InitTweak/GenInit.h

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // GenInit.h --
+// RemoveInit.h --
 //
 // Author           : Rodolfo G. Esteves
 …
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
-        /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl );
 } // namespace

src/InitTweak/InitTweak.cc

-              r1f44196
+              r3a2128f
                 return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_result() );
+                                assert( ! appExpr->get_function()->get_results().empty() );
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
                                 assert( funcType );
                                 return funcType->get_parameters().size() == 1;
 …
                                 return memberExpr->get_member()->get_name();
                         } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
                                 return funcName( memberExpr->get_member() );
+                                return memberExpr->get_member();
                         } else {
                                 assertf( false, "Unexpected expression type being called as a function in call expression" );
 …
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
                 virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
                 virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
                 virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
                 bool isConstExpr;

src/Makefile.in

-              r1f44196
+              r3a2128f
         ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
+        ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
 …
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
         Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
+        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
+        Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
+        Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
 am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
 driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
 …
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
+        ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
 …
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
+        SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
+        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc
+        SynTree/Attribute.cc Tuples/TupleAssignment.cc \
+        Tuples/NameMatcher.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
 …
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
+        ControlStruct/$(am__dirstamp) \
+        ControlStruct/$(DEPDIR)/$(am__dirstamp)
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT):  \
         ControlStruct/$(am__dirstamp) \
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
 …
 SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
 …
 Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT):  \
         Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
+Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT):  \
+        Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
+Tuples/driver_cfa_cpp-Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
+Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 driver/$(am__dirstamp):
 …
         -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT)
+        -rm -f ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-MLEMutator.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT)
 …
         -rm -f SynTree/driver_cfa_cpp-TypeofType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT)
-        -rm -f SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
+        -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
-        -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
 distclean-compile:
 …
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-MLEMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
 .cc.o:
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi`
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.o: ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.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 ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj: ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.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 ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
 GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.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-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
-SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
-SynTree/driver_cfa_cpp-VarExprReplacer.obj: SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
 Tuples/driver_cfa_cpp-TupleAssignment.o: Tuples/TupleAssignment.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleAssignment.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Tpo -c -o Tuples/driver_cfa_cpp-TupleAssignment.o `test -f 'Tuples/TupleAssignment.cc' || echo '$(srcdir)/'`Tuples/TupleAssignment.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-TupleAssignment.obj `if test -f 'Tuples/TupleAssignment.cc'; then $(CYGPATH_W) 'Tuples/TupleAssignment.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleAssignment.cc'; fi`
+Tuples/driver_cfa_cpp-TupleExpansion.o: Tuples/TupleExpansion.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleExpansion.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo -c -o Tuples/driver_cfa_cpp-TupleExpansion.o `test -f 'Tuples/TupleExpansion.cc' || echo '$(srcdir)/'`Tuples/TupleExpansion.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.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 Tuples/driver_cfa_cpp-TupleExpansion.o `test -f 'Tuples/TupleExpansion.cc' || echo '$(srcdir)/'`Tuples/TupleExpansion.cc
+Tuples/driver_cfa_cpp-TupleExpansion.obj: Tuples/TupleExpansion.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleExpansion.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo -c -o Tuples/driver_cfa_cpp-TupleExpansion.obj `if test -f 'Tuples/TupleExpansion.cc'; then $(CYGPATH_W) 'Tuples/TupleExpansion.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleExpansion.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.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 Tuples/driver_cfa_cpp-TupleExpansion.obj `if test -f 'Tuples/TupleExpansion.cc'; then $(CYGPATH_W) 'Tuples/TupleExpansion.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleExpansion.cc'; fi`
+Tuples/driver_cfa_cpp-Explode.o: Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.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 Tuples/driver_cfa_cpp-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
+Tuples/driver_cfa_cpp-Explode.obj: Tuples/Explode.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.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 Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
+Tuples/driver_cfa_cpp-NameMatcher.o: Tuples/NameMatcher.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-NameMatcher.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo -c -o Tuples/driver_cfa_cpp-NameMatcher.o `test -f 'Tuples/NameMatcher.cc' || echo '$(srcdir)/'`Tuples/NameMatcher.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.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 Tuples/driver_cfa_cpp-NameMatcher.o `test -f 'Tuples/NameMatcher.cc' || echo '$(srcdir)/'`Tuples/NameMatcher.cc
+Tuples/driver_cfa_cpp-NameMatcher.obj: Tuples/NameMatcher.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-NameMatcher.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo -c -o Tuples/driver_cfa_cpp-NameMatcher.obj `if test -f 'Tuples/NameMatcher.cc'; then $(CYGPATH_W) 'Tuples/NameMatcher.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/NameMatcher.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.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 Tuples/driver_cfa_cpp-NameMatcher.obj `if test -f 'Tuples/NameMatcher.cc'; then $(CYGPATH_W) 'Tuples/NameMatcher.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/NameMatcher.cc'; fi`
 .ll.cc:

src/Parser/ExpressionNode.cc

-              r1f44196
+              r3a2128f
 } // build_constantStr
-Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
-        // str is of the form A.B -> separate at the . and return member expression
-        int a, b;
-        char dot;
-        std::stringstream ss( str );
-        ss >> a >> dot >> b;
-        UntypedMemberExpr * ret = new UntypedMemberExpr(
-                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( b ) ) ),
-                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( a ) ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_FLOATINGconstant
-Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
-        if ( fracts ) {
-                if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
-                        memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
-                        return memberExpr;
-                } else {
-                        return new UntypedMemberExpr( fracts, fieldName );
+                }
+        }
-        return fieldName;
-} // make_field_name_fraction_constants
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
-        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
-} // build_field_name_fraction_constants
-Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
-        assert( str[0] == '.' );
-        Expression * ret = build_constantInteger( *new std::string( str.substr(1) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALFRACTIONconstant
-Expression * build_field_name_REALDECIMALconstant( const std::string & str ) {
-        assert( str[str.size()-1] == '.' );
-        Expression * ret = build_constantInteger( *new std::string( str.substr( 0, str.size()-1 ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALDECIMALconstant
 NameExpr * build_varref( const string *name, bool labelp ) {
         NameExpr *expr = new NameExpr( *name, nullptr );
 …
+}
+Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member ) {
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return ret;
+}
+Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
+Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) );
+        delete member;
+        return ret;
+}
+Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
+        delete member;
         return ret;
+}

src/Parser/ParseNode.h

-              r1f44196
+              r3a2128f
 Expression * build_constantChar( const std::string &str );
 ConstantExpr * build_constantStr( const std::string &str );
-Expression * build_field_name_FLOATINGconstant( const std::string & str );
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
-Expression * build_field_name_REALDECIMALconstant( const std::string & str );
 NameExpr * build_varref( const std::string * name, bool labelp = false );
 …
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
 Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
+Expression * build_fieldSel( ExpressionNode * expr_node, NameExpr * member );
+Expression * build_pfieldSel( ExpressionNode * expr_node, NameExpr * member );
 Expression * build_addressOf( ExpressionNode * expr_node );
 Expression * build_sizeOfexpr( ExpressionNode * expr_node );
 …
 //##############################################################################
 template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
 void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
+template< typename SynTreeType, typename NodeType >
+void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
+        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
         const NodeType * cur = firstNode;

src/Parser/TypeData.cc

-              r1f44196
+              r3a2128f
 } // TypeData::print
+template< typename ForallList >
+void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
+void buildForall( const DeclarationNode * firstNode, list< TypeDecl* > &outputList ) {
         buildList( firstNode, outputList );
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+                TypeDecl * td = static_cast<TypeDecl*>(*i);
+                if ( td->get_kind() == TypeDecl::Any ) {
+        for ( list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+                if ( (*i)->get_kind() == TypeDecl::Any ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
                 } // if
         } // for
 …
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
                 // either signed char or unsigned char.
                 static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
+                static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
                 if ( td->length != DeclarationNode::NoLength ) {

src/Parser/parser.cc

-              r1f44196
+              r3a2128f
 static const yytype_uint16 yyrline[] =
+{
 ,   305,   305,   309,   316,   317,   318,   319,   320,   324,
 ,   326,   330,   331,   335,   336,   340,   341,   345,   349,
 ,   361,   363,   365,   366,   368,   373,   374,   380,   382,
 ,   386,   388,   390,   392,   394,   396,   398,   407,   408,
 ,   415,   419,   420,   424,   425,   427,   429,   431,   433,
 ,   440,   442,   444,   450,   451,   459,   462,   464,   466,
 ,   484,   486,   488,   490,   492,   494,   496,   498,   500,
 ,   504,   511,   512,   518,   519,   520,   521,   525,   526,
 ,   534,   536,   538,   543,   544,   546,   551,   552,   554,
 ,   560,   562,   564,   566,   571,   572,   574,   579,   580,
 ,   586,   591,   592,   597,   598,   603,   604,   609,   610,
 ,   620,   625,   626,   634,   635,   639,   640,   641,   642,
 ,   644,   645,   646,   647,   648,   649,   650,   660,   662,
 ,   668,   673,   674,   680,   681,   687,   688,   689,   690,
 ,   692,   693,   694,   695,   705,   712,   714,   724,   725,
 ,   732,   738,   740,   744,   745,   750,   755,   758,   760,
 ,   772,   774,   785,   786,   788,   792,   794,   798,   799,
 ,   805,   809,   814,   815,   819,   821,   827,   828,   832,
 ,   836,   838,   844,   845,   849,   851,   856,   858,   860,
 ,   867,   872,   874,   878,   881,   885,   888,   892,   894,
 ,   898,   903,   905,   907,   912,   914,   916,   918,   920,
 ,   927,   929,   931,   936,   948,   949,   954,   956,   961,
 ,   967,   969,   971,   973,   979,   980,   986,   987,   991,
 ,   997,   999,  1005,  1006,  1008,  1013,  1018,  1028,  1030,
 ,  1035,  1040,  1042,  1046,  1047,  1051,  1053,  1057,  1058,
 ,  1063,  1067,  1068,  1083,  1084,  1085,  1086,  1087,  1091,
 ,  1103,  1113,  1118,  1123,  1131,  1136,  1141,  1146,  1151,
 ,  1186,  1193,  1195,  1202,  1207,  1212,  1223,  1228,  1233,
 ,  1243,  1252,  1257,  1265,  1266,  1267,  1268,  1274,  1279,
 ,  1288,  1289,  1290,  1294,  1295,  1296,  1297,  1302,  1303,
 ,  1313,  1318,  1319,  1324,  1326,  1328,  1330,  1332,  1335,
 ,  1346,  1347,  1349,  1359,  1360,  1365,  1367,  1369,  1371,
 ,  1376,  1378,  1381,  1386,  1388,  1390,  1392,  1394,  1396,
 ,  1400,  1402,  1404,  1406,  1408,  1410,  1412,  1414,  1420,
 ,  1423,  1425,  1427,  1432,  1433,  1439,  1440,  1442,  1444,
 ,  1451,  1453,  1455,  1460,  1461,  1463,  1465,  1470,  1471,
 ,  1478,  1479,  1481,  1483,  1488,  1490,  1492,  1497,  1498,
 ,  1504,  1510,  1509,  1513,  1515,  1520,  1522,  1528,  1529,
 ,  1535,  1537,  1538,  1547,  1548,  1550,  1552,  1557,  1559,
 ,  1566,  1568,  1571,  1574,  1579,  1580,  1585,  1590,  1594,
 ,  1602,  1601,  1608,  1610,  1616,  1617,  1625,  1626,  1630,
 ,  1632,  1634,  1636,  1643,  1644,  1646,  1648,  1653,  1654,
 ,  1661,  1665,  1666,  1671,  1672,  1673,  1675,  1683,  1684,
 ,  1689,  1691,  1695,  1696,  1697,  1699,  1701,  1705,  1710,
 ,  1719,  1728,  1730,  1735,  1736,  1737,  1741,  1742,  1743,
 ,  1748,  1749,  1753,  1754,  1755,  1760,  1761,  1762,  1763,
 ,  1770,  1772,  1777,  1778,  1783,  1784,  1785,  1786,  1787,
 ,  1803,  1808,  1809,  1815,  1817,  1820,  1822,  1824,  1847,
 ,  1850,  1852,  1857,  1858,  1860,  1865,  1870,  1871,  1877,
 ,  1880,  1884,  1886,  1888,  1894,  1895,  1900,  1905,  1907,
 ,  1914,  1915,  1917,  1922,  1924,  1926,  1931,  1933,  1938,
 ,  1951,  1957,  1956,  1970,  1971,  1976,  1977,  1981,  1986,
 ,  1999,  2004,  2015,  2016,  2021,  2022,  2028,  2029,  2033,
 ,  2035,  2038,  2037,  2048,  2057,  2063,  2069,  2078,  2084,
 ,  2096,  2102,  2110,  2116,  2124,  2130,  2139,  2140,  2141,
 ,  2149,  2151,  2156,  2157,  2161,  2162,  2167,  2173,  2174,
 ,  2179,  2180,  2184,  2185,  2186,  2187,  2221,  2223,  2224,
 ,  2231,  2236,  2241,  2243,  2245,  2250,  2252,  2254,  2256,
 ,  2263,  2272,  2274,  2275,  2280,  2282,  2284,  2289,  2291,
 ,  2298,  2300,  2302,  2311,  2312,  2313,  2317,  2319,  2321,
 ,  2328,  2330,  2335,  2337,  2339,  2354,  2356,  2357,  2359,
 ,  2365,  2370,  2372,  2374,  2379,  2381,  2383,  2385,  2390,
 ,  2394,  2404,  2406,  2407,  2409,  2414,  2416,  2418,  2423,
 ,  2427,  2429,  2434,  2436,  2438,  2469,  2471,  2472,  2474,
 ,  2484,  2492,  2494,  2496,  2501,  2503,  2508,  2510,  2524,
 ,  2527,  2532,  2534,  2536,  2538,  2540,  2545,  2546,  2548,
 ,  2555,  2557,  2559,  2565,  2567,  2569,  2573,  2575,  2577,
 ,  2593,  2594,  2596,  2601,  2603,  2605,  2607,  2609,  2614,
 ,  2617,  2619,  2624,  2626,  2628,  2634,  2635,  2637,  2646,
 ,  2651,  2654,  2656,  2658,  2671,  2672,  2674,  2679,  2681,
 ,  2685,  2687,  2692,  2693,  2695,  2697,  2702,  2704,  2712,
 ,  2714,  2719,  2720,  2724,  2726,  2728,  2730,  2732,  2734,
 ,  2743,  2745,  2747,  2749,  2752,  2754,  2756,  2758,  2760,
 ,  2767,  2769,  2774,  2800,  2801,  2803,  2807,  2808,  2812,
 ,  2816,  2818,  2820,  2822,  2829,  2831,  2833,  2835,  2837,
 ,  2844,  2851,  2853,  2871,  2873,  2878,  2879
+,   306,   306,   310,   317,   318,   319,   320,   321,   325,
+,   327,   331,   332,   336,   337,   341,   342,   346,   350,
+,   362,   364,   366,   367,   369,   374,   375,   381,   383,
+,   386,   387,   389,   390,   392,   394,   396,   405,   406,
+,   413,   417,   418,   422,   424,   426,   428,   430,   432,
+,   439,   441,   443,   447,   449,   453,   456,   458,   460,
+,   478,   480,   482,   484,   486,   488,   490,   492,   494,
+,   498,   505,   506,   512,   513,   514,   515,   519,   520,
+,   528,   530,   532,   537,   538,   540,   545,   546,   548,
+,   554,   556,   558,   560,   565,   566,   568,   573,   574,
+,   580,   585,   586,   591,   592,   597,   598,   603,   604,
+,   614,   619,   620,   628,   629,   633,   634,   635,   636,
+,   638,   639,   640,   641,   642,   643,   644,   654,   656,
+,   662,   667,   668,   674,   675,   681,   682,   683,   684,
+,   686,   687,   688,   689,   699,   706,   708,   718,   719,
+,   726,   732,   734,   738,   739,   744,   749,   752,   754,
+,   766,   768,   779,   780,   782,   786,   788,   792,   793,
+,   799,   803,   808,   809,   813,   815,   821,   822,   826,
+,   830,   832,   838,   839,   843,   845,   850,   852,   854,
+,   861,   866,   868,   872,   875,   879,   882,   886,   888,
+,   892,   897,   899,   901,   906,   908,   910,   912,   914,
+,   921,   923,   925,   930,   942,   943,   948,   950,   955,
+,   961,   963,   965,   967,   973,   974,   980,   981,   985,
+,   991,   993,   999,  1000,  1002,  1007,  1012,  1022,  1024,
+,  1029,  1034,  1036,  1040,  1041,  1045,  1047,  1051,  1052,
+,  1057,  1061,  1062,  1077,  1078,  1079,  1080,  1081,  1085,
+,  1097,  1107,  1112,  1117,  1125,  1130,  1135,  1140,  1145,
+,  1180,  1187,  1189,  1196,  1201,  1206,  1217,  1222,  1227,
+,  1237,  1246,  1251,  1259,  1260,  1261,  1262,  1268,  1273,
+,  1282,  1283,  1284,  1288,  1289,  1290,  1291,  1296,  1297,
+,  1307,  1312,  1313,  1318,  1320,  1322,  1324,  1326,  1329,
+,  1340,  1341,  1343,  1353,  1354,  1359,  1361,  1363,  1365,
+,  1370,  1372,  1375,  1380,  1382,  1384,  1386,  1388,  1390,
+,  1394,  1396,  1398,  1400,  1402,  1404,  1406,  1408,  1414,
+,  1417,  1419,  1421,  1426,  1427,  1433,  1434,  1436,  1438,
+,  1445,  1447,  1449,  1454,  1455,  1457,  1459,  1464,  1465,
+,  1472,  1473,  1475,  1477,  1482,  1484,  1486,  1491,  1492,
+,  1498,  1504,  1503,  1507,  1509,  1514,  1516,  1522,  1523,
+,  1529,  1531,  1532,  1541,  1542,  1544,  1546,  1551,  1553,
+,  1560,  1562,  1565,  1568,  1573,  1574,  1579,  1584,  1588,
+,  1596,  1595,  1602,  1604,  1610,  1611,  1619,  1620,  1624,
+,  1626,  1628,  1630,  1637,  1638,  1640,  1642,  1647,  1648,
+,  1655,  1659,  1660,  1665,  1666,  1667,  1669,  1677,  1678,
+,  1683,  1685,  1689,  1690,  1691,  1693,  1695,  1699,  1704,
+,  1713,  1722,  1724,  1729,  1730,  1731,  1735,  1736,  1737,
+,  1742,  1743,  1747,  1748,  1749,  1754,  1755,  1756,  1757,
+,  1764,  1766,  1771,  1772,  1777,  1778,  1779,  1780,  1781,
+,  1797,  1802,  1803,  1809,  1811,  1814,  1816,  1818,  1841,
+,  1844,  1846,  1851,  1852,  1854,  1859,  1864,  1865,  1871,
+,  1874,  1878,  1880,  1882,  1888,  1889,  1894,  1899,  1901,
+,  1908,  1909,  1911,  1916,  1918,  1920,  1925,  1927,  1932,
+,  1945,  1951,  1950,  1964,  1965,  1970,  1971,  1975,  1980,
+,  1993,  1998,  2009,  2010,  2015,  2016,  2022,  2023,  2027,
+,  2029,  2032,  2031,  2042,  2051,  2057,  2063,  2072,  2078,
+,  2090,  2096,  2104,  2110,  2118,  2124,  2133,  2134,  2135,
+,  2143,  2145,  2150,  2151,  2155,  2156,  2161,  2167,  2168,
+,  2173,  2174,  2178,  2179,  2180,  2181,  2215,  2217,  2218,
+,  2225,  2230,  2235,  2237,  2239,  2244,  2246,  2248,  2250,
+,  2257,  2266,  2268,  2269,  2274,  2276,  2278,  2283,  2285,
+,  2292,  2294,  2296,  2305,  2306,  2307,  2311,  2313,  2315,
+,  2322,  2324,  2329,  2331,  2333,  2348,  2350,  2351,  2353,
+,  2359,  2364,  2366,  2368,  2373,  2375,  2377,  2379,  2384,
+,  2388,  2398,  2400,  2401,  2403,  2408,  2410,  2412,  2417,
+,  2421,  2423,  2428,  2430,  2432,  2463,  2465,  2466,  2468,
+,  2478,  2486,  2488,  2490,  2495,  2497,  2502,  2504,  2518,
+,  2521,  2526,  2528,  2530,  2532,  2534,  2539,  2540,  2542,
+,  2549,  2551,  2553,  2559,  2561,  2563,  2567,  2569,  2571,
+,  2587,  2588,  2590,  2595,  2597,  2599,  2601,  2603,  2608,
+,  2611,  2613,  2618,  2620,  2622,  2628,  2629,  2631,  2640,
+,  2645,  2648,  2650,  2652,  2665,  2666,  2668,  2673,  2675,
+,  2679,  2681,  2686,  2687,  2689,  2691,  2696,  2698,  2706,
+,  2708,  2713,  2714,  2718,  2720,  2722,  2724,  2726,  2728,
+,  2737,  2739,  2741,  2743,  2746,  2748,  2750,  2752,  2754,
+,  2761,  2763,  2768,  2794,  2795,  2797,  2801,  2802,  2806,
+,  2810,  2812,  2814,  2816,  2823,  2825,  2827,  2829,  2831,
+,  2838,  2845,  2847,  2865,  2867,  2872,  2873
 };
 #endif
 …
 /* Line 1806 of yacc.c  */
 #line 305 "parser.yy"
+#line 306 "parser.yy"
     { typedefTable.enterScope(); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 309 "parser.yy"
+#line 310 "parser.yy"
     { typedefTable.leaveScope(); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 316 "parser.yy"
+#line 317 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
   case 5:
-/* Line 1806 of yacc.c  */
-#line 317 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
-    break;
-  case 6:
 /* Line 1806 of yacc.c  */
 …
     break;
   case 7:
+  case 6:
 /* Line 1806 of yacc.c  */
 …
     break;
+  case 7:
+/* Line 1806 of yacc.c  */
+#line 320 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
+    break;
   case 8:
 /* Line 1806 of yacc.c  */
 #line 320 "parser.yy"
+#line 321 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 345 "parser.yy"
+#line 346 "parser.yy"
     { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 349 "parser.yy"
+#line 350 "parser.yy"
     { (yyval.str) = (yyvsp[(1) - (1)].tok); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 351 "parser.yy"
+#line 352 "parser.yy"
+    {
                         appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
 …
 /* Line 1806 of yacc.c  */
 #line 362 "parser.yy"
+#line 363 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 364 "parser.yy"
+#line 365 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 367 "parser.yy"
+#line 368 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (3)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 369 "parser.yy"
+#line 370 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 379 "parser.yy"
+#line 380 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 381 "parser.yy"
+#line 382 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 383 "parser.yy"
+#line 384 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
-  case 30:
-/* Line 1806 of yacc.c  */
-#line 385 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
-    break;
-  case 31:
-/* Line 1806 of yacc.c  */
-#line 387 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en), build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) ) ) ); }
-    break;
   case 32:
 /* Line 1806 of yacc.c  */
 #line 389 "parser.yy"
+#line 388 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
   case 33:
+  case 34:
 /* Line 1806 of yacc.c  */
 #line 391 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
     break;
   case 34:
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
+    break;
+  case 35:
 /* Line 1806 of yacc.c  */
 #line 393 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
   case 35:
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
+    break;
+  case 36:
 /* Line 1806 of yacc.c  */
 #line 395 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
   case 36:
+    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
+    break;
+  case 37:
 /* Line 1806 of yacc.c  */
 #line 397 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
-    break;
-  case 37:
-/* Line 1806 of yacc.c  */
-#line 399 "parser.yy"
+    {
                         Token fn;
 …
 /* Line 1806 of yacc.c  */
 #line 409 "parser.yy"
+#line 407 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 414 "parser.yy"
+#line 412 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 420 "parser.yy"
+#line 418 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
+  case 44:
+/* Line 1806 of yacc.c  */
+#line 423 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
+    break;
   case 45:
 /* Line 1806 of yacc.c  */
 #line 426 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (2)].tok) ) ), maybeMoveBuild<Expression>( (yyvsp[(2) - (2)].en) ) ) ); }
+#line 425 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(2) - (2)].en), build_varref( (yyvsp[(1) - (2)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 428 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (6)].tok) ) ), build_tuple( (yyvsp[(4) - (6)].en) ) ) ); }
+#line 427 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(4) - (6)].en), build_varref( (yyvsp[(1) - (6)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 430 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
+#line 429 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 432 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
+#line 431 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 434 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
+#line 433 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 436 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
+#line 435 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 441 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
+#line 440 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 443 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
+#line 442 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 445 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_varref( (yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 54:
+/* Line 1806 of yacc.c  */
+#line 450 "parser.yy"
+    { (yyval.en) = nullptr; }
+    break;
+  case 55:
+/* Line 1806 of yacc.c  */
+#line 452 "parser.yy"
+    {
+                        Expression * constant = build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) );
+                        (yyval.en) = (yyvsp[(1) - (2)].en) != nullptr ? new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en),  constant ) ) : new ExpressionNode( constant );
+                }
+#line 444 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 463 "parser.yy"
+#line 457 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 465 "parser.yy"
+#line 459 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 467 "parser.yy"
+#line 461 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 472 "parser.yy"
+#line 466 "parser.yy"
+    {
                         switch ( (yyvsp[(1) - (2)].op) ) {
 …
 /* Line 1806 of yacc.c  */
+#line 479 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 62:
+/* Line 1806 of yacc.c  */
+#line 481 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 63:
+/* Line 1806 of yacc.c  */
+#line 483 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 64:
+/* Line 1806 of yacc.c  */
 #line 485 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
     break;
   case 62:
+    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 65:
 /* Line 1806 of yacc.c  */
 #line 487 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
     break;
   case 63:
+    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+  case 66:
 /* Line 1806 of yacc.c  */
 #line 489 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
     break;
   case 64:
+    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 67:
 /* Line 1806 of yacc.c  */
 #line 491 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
   case 65:
+    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+  case 68:
 /* Line 1806 of yacc.c  */
 #line 493 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
   case 66:
+    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
+    break;
+  case 69:
 /* Line 1806 of yacc.c  */
 #line 495 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
   case 67:
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
+    break;
+  case 70:
 /* Line 1806 of yacc.c  */
 #line 497 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
   case 68:
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
+    break;
+  case 71:
 /* Line 1806 of yacc.c  */
 #line 499 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
+    break;
+  case 69:
+/* Line 1806 of yacc.c  */
+#line 501 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
+    break;
+  case 70:
+/* Line 1806 of yacc.c  */
+#line 503 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
+    break;
+  case 71:
+    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+  case 72:
 /* Line 1806 of yacc.c  */
 #line 505 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
-    break;
-  case 72:
-/* Line 1806 of yacc.c  */
-#line 511 "parser.yy"
     { (yyval.op) = OperKinds::PointTo; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 506 "parser.yy"
+    { (yyval.op) = OperKinds::AddressOf; }
+    break;
+  case 74:
+/* Line 1806 of yacc.c  */
 #line 512 "parser.yy"
-    { (yyval.op) = OperKinds::AddressOf; }
-    break;
-  case 74:
-/* Line 1806 of yacc.c  */
-#line 518 "parser.yy"
     { (yyval.op) = OperKinds::UnPlus; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 519 "parser.yy"
+#line 513 "parser.yy"
     { (yyval.op) = OperKinds::UnMinus; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 520 "parser.yy"
+#line 514 "parser.yy"
     { (yyval.op) = OperKinds::Neg; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 515 "parser.yy"
+    { (yyval.op) = OperKinds::BitNeg; }
+    break;
+  case 79:
+/* Line 1806 of yacc.c  */
 #line 521 "parser.yy"
-    { (yyval.op) = OperKinds::BitNeg; }
-    break;
-  case 79:
-/* Line 1806 of yacc.c  */
-#line 527 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 535 "parser.yy"
+#line 529 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 537 "parser.yy"
+#line 531 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 533 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 85:
+/* Line 1806 of yacc.c  */
 #line 539 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-  case 85:
-/* Line 1806 of yacc.c  */
-#line 545 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 541 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 88:
+/* Line 1806 of yacc.c  */
 #line 547 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-  case 88:
-/* Line 1806 of yacc.c  */
-#line 553 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 549 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 91:
+/* Line 1806 of yacc.c  */
 #line 555 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 91:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 92:
+/* Line 1806 of yacc.c  */
+#line 557 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 93:
+/* Line 1806 of yacc.c  */
+#line 559 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 94:
 /* Line 1806 of yacc.c  */
 #line 561 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 92:
+/* Line 1806 of yacc.c  */
+#line 563 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 93:
+/* Line 1806 of yacc.c  */
+#line 565 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 94:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 96:
 /* Line 1806 of yacc.c  */
 #line 567 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-  case 96:
-/* Line 1806 of yacc.c  */
-#line 573 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 569 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 99:
+/* Line 1806 of yacc.c  */
 #line 575 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
   case 99:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 101:
 /* Line 1806 of yacc.c  */
 #line 581 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
   case 101:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 103:
 /* Line 1806 of yacc.c  */
 #line 587 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
   case 103:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+  case 105:
 /* Line 1806 of yacc.c  */
 #line 593 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
   case 105:
+    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
+    break;
+  case 107:
 /* Line 1806 of yacc.c  */
 #line 599 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     break;
   case 107:
+    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
+    break;
+  case 109:
 /* Line 1806 of yacc.c  */
 #line 605 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
-    break;
-  case 109:
-/* Line 1806 of yacc.c  */
-#line 611 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 614 "parser.yy"
+#line 608 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 627 "parser.yy"
+#line 621 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 628 "parser.yy"
+    { (yyval.en) = nullptr; }
+    break;
+  case 116:
+/* Line 1806 of yacc.c  */
+#line 633 "parser.yy"
+    { (yyval.op) = OperKinds::Assign; }
+    break;
+  case 117:
+/* Line 1806 of yacc.c  */
 #line 634 "parser.yy"
+    { (yyval.en) = nullptr; }
+    break;
+  case 116:
+    { (yyval.op) = OperKinds::AtAssn; }
+    break;
+  case 118:
+/* Line 1806 of yacc.c  */
+#line 635 "parser.yy"
+    { (yyval.op) = OperKinds::MulAssn; }
+    break;
+  case 119:
+/* Line 1806 of yacc.c  */
+#line 636 "parser.yy"
+    { (yyval.op) = OperKinds::DivAssn; }
+    break;
+  case 120:
+/* Line 1806 of yacc.c  */
+#line 637 "parser.yy"
+    { (yyval.op) = OperKinds::ModAssn; }
+    break;
+  case 121:
+/* Line 1806 of yacc.c  */
+#line 638 "parser.yy"
+    { (yyval.op) = OperKinds::PlusAssn; }
+    break;
+  case 122:
 /* Line 1806 of yacc.c  */
 #line 639 "parser.yy"
     { (yyval.op) = OperKinds::Assign; }
     break;
   case 117:
+    { (yyval.op) = OperKinds::MinusAssn; }
+    break;
+  case 123:
 /* Line 1806 of yacc.c  */
 #line 640 "parser.yy"
     { (yyval.op) = OperKinds::AtAssn; }
     break;
   case 118:
+    { (yyval.op) = OperKinds::LSAssn; }
+    break;
+  case 124:
 /* Line 1806 of yacc.c  */
 #line 641 "parser.yy"
     { (yyval.op) = OperKinds::MulAssn; }
     break;
   case 119:
+    { (yyval.op) = OperKinds::RSAssn; }
+    break;
+  case 125:
 /* Line 1806 of yacc.c  */
 #line 642 "parser.yy"
     { (yyval.op) = OperKinds::DivAssn; }
     break;
   case 120:
+    { (yyval.op) = OperKinds::AndAssn; }
+    break;
+  case 126:
 /* Line 1806 of yacc.c  */
 #line 643 "parser.yy"
     { (yyval.op) = OperKinds::ModAssn; }
     break;
   case 121:
+    { (yyval.op) = OperKinds::ERAssn; }
+    break;
+  case 127:
 /* Line 1806 of yacc.c  */
 #line 644 "parser.yy"
-    { (yyval.op) = OperKinds::PlusAssn; }
-    break;
-  case 122:
-/* Line 1806 of yacc.c  */
-#line 645 "parser.yy"
-    { (yyval.op) = OperKinds::MinusAssn; }
-    break;
-  case 123:
-/* Line 1806 of yacc.c  */
-#line 646 "parser.yy"
-    { (yyval.op) = OperKinds::LSAssn; }
-    break;
-  case 124:
-/* Line 1806 of yacc.c  */
-#line 647 "parser.yy"
-    { (yyval.op) = OperKinds::RSAssn; }
-    break;
-  case 125:
-/* Line 1806 of yacc.c  */
-#line 648 "parser.yy"
-    { (yyval.op) = OperKinds::AndAssn; }
-    break;
-  case 126:
-/* Line 1806 of yacc.c  */
-#line 649 "parser.yy"
-    { (yyval.op) = OperKinds::ERAssn; }
-    break;
-  case 127:
-/* Line 1806 of yacc.c  */
-#line 650 "parser.yy"
     { (yyval.op) = OperKinds::OrAssn; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 661 "parser.yy"
+#line 655 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 657 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
+    break;
+  case 131:
+/* Line 1806 of yacc.c  */
 #line 663 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
     break;
   case 131:
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
+    break;
+  case 133:
 /* Line 1806 of yacc.c  */
 #line 669 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
-    break;
-  case 133:
-/* Line 1806 of yacc.c  */
-#line 675 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 680 "parser.yy"
+#line 674 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 689 "parser.yy"
+#line 683 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 696 "parser.yy"
+#line 690 "parser.yy"
+    {
                         Token fn;
 …
 /* Line 1806 of yacc.c  */
 #line 706 "parser.yy"
+#line 700 "parser.yy"
+    {
                         (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 713 "parser.yy"
+#line 707 "parser.yy"
     { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 714 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
+    break;
+  case 149:
+/* Line 1806 of yacc.c  */
 #line 720 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
-    break;
-  case 149:
-/* Line 1806 of yacc.c  */
-#line 726 "parser.yy"
     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 731 "parser.yy"
+#line 725 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 733 "parser.yy"
+#line 727 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
 …
 /* Line 1806 of yacc.c  */
 #line 739 "parser.yy"
+#line 733 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 746 "parser.yy"
+#line 740 "parser.yy"
     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 745 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
+    break;
+  case 157:
+/* Line 1806 of yacc.c  */
 #line 751 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
+    break;
+  case 157:
+    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
+    break;
+  case 158:
+/* Line 1806 of yacc.c  */
+#line 753 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
+    break;
+  case 159:
+/* Line 1806 of yacc.c  */
+#line 755 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+  case 160:
 /* Line 1806 of yacc.c  */
 #line 757 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
-    break;
-  case 158:
-/* Line 1806 of yacc.c  */
-#line 759 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
-    break;
-  case 159:
-/* Line 1806 of yacc.c  */
-#line 761 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
-    break;
-  case 160:
-/* Line 1806 of yacc.c  */
-#line 763 "parser.yy"
+    {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
 …
 /* Line 1806 of yacc.c  */
 #line 773 "parser.yy"
+#line 767 "parser.yy"
     { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 775 "parser.yy"
+#line 769 "parser.yy"
+    {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
 …
 /* Line 1806 of yacc.c  */
 #line 785 "parser.yy"
+#line 779 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 787 "parser.yy"
+#line 781 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 786 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
+    break;
+  case 167:
+/* Line 1806 of yacc.c  */
+#line 788 "parser.yy"
+    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
+    break;
+  case 168:
+/* Line 1806 of yacc.c  */
 #line 792 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
-    break;
-  case 167:
-/* Line 1806 of yacc.c  */
-#line 794 "parser.yy"
-    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
-    break;
-  case 168:
-/* Line 1806 of yacc.c  */
-#line 798 "parser.yy"
     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 793 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_default() ); }
+    break;
+  case 171:
+/* Line 1806 of yacc.c  */
 #line 799 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_default() ); }
-    break;
-  case 171:
-/* Line 1806 of yacc.c  */
-#line 805 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 809 "parser.yy"
+#line 803 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 808 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+  case 175:
+/* Line 1806 of yacc.c  */
 #line 814 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
+    break;
+  case 176:
+/* Line 1806 of yacc.c  */
+#line 816 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
+    break;
+  case 177:
+/* Line 1806 of yacc.c  */
+#line 821 "parser.yy"
     { (yyval.sn) = 0; }
     break;
+  case 175:
+/* Line 1806 of yacc.c  */
+#line 820 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
+    break;
+  case 176:
+/* Line 1806 of yacc.c  */
+#line 822 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
+    break;
+  case 177:
+  case 179:
 /* Line 1806 of yacc.c  */
 #line 827 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
+    break;
+  case 180:
+/* Line 1806 of yacc.c  */
+#line 829 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
+    break;
+  case 181:
+/* Line 1806 of yacc.c  */
+#line 831 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
+    break;
+  case 182:
+/* Line 1806 of yacc.c  */
+#line 833 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
+    break;
+  case 183:
+/* Line 1806 of yacc.c  */
+#line 838 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
+    break;
+  case 185:
+/* Line 1806 of yacc.c  */
+#line 844 "parser.yy"
     { (yyval.sn) = 0; }
     break;
+  case 179:
+/* Line 1806 of yacc.c  */
+#line 833 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
+    break;
+  case 180:
+/* Line 1806 of yacc.c  */
+#line 835 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
+    break;
+  case 181:
+/* Line 1806 of yacc.c  */
+#line 837 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
+    break;
+  case 182:
+/* Line 1806 of yacc.c  */
+#line 839 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
+    break;
+  case 183:
+/* Line 1806 of yacc.c  */
+#line 844 "parser.yy"
+  case 186:
+/* Line 1806 of yacc.c  */
+#line 846 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+  case 187:
+/* Line 1806 of yacc.c  */
+#line 851 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+  case 188:
+/* Line 1806 of yacc.c  */
+#line 853 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
+    break;
+  case 189:
+/* Line 1806 of yacc.c  */
+#line 855 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
+    break;
+  case 190:
+/* Line 1806 of yacc.c  */
+#line 860 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
+    break;
+  case 191:
+/* Line 1806 of yacc.c  */
+#line 862 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
+    break;
+  case 192:
+/* Line 1806 of yacc.c  */
+#line 867 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
+    break;
+  case 193:
+/* Line 1806 of yacc.c  */
+#line 871 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
+    break;
+  case 194:
+/* Line 1806 of yacc.c  */
+#line 874 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+    break;
+  case 195:
+/* Line 1806 of yacc.c  */
+#line 878 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
+    break;
+  case 196:
+/* Line 1806 of yacc.c  */
+#line 881 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
     break;
+  case 185:
+/* Line 1806 of yacc.c  */
+#line 850 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+  case 186:
+/* Line 1806 of yacc.c  */
+#line 852 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+  case 187:
+/* Line 1806 of yacc.c  */
+#line 857 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+  case 188:
+/* Line 1806 of yacc.c  */
+#line 859 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
+    break;
+  case 189:
+/* Line 1806 of yacc.c  */
+#line 861 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
+    break;
+  case 190:
+/* Line 1806 of yacc.c  */
+#line 866 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
+    break;
+  case 191:
+/* Line 1806 of yacc.c  */
+#line 868 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
+    break;
+  case 192:
+/* Line 1806 of yacc.c  */
+#line 873 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
+    break;
+  case 193:
+/* Line 1806 of yacc.c  */
+#line 877 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
+    break;
+  case 194:
+/* Line 1806 of yacc.c  */
+#line 880 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+    break;
+  case 195:
+/* Line 1806 of yacc.c  */
+#line 884 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
+    break;
+  case 196:
+  case 197:
+/* Line 1806 of yacc.c  */
+#line 885 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
+    break;
+  case 198:
 /* Line 1806 of yacc.c  */
 #line 887 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
+    break;
+  case 197:
+    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+  case 199:
+/* Line 1806 of yacc.c  */
+#line 889 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+  case 200:
 /* Line 1806 of yacc.c  */
 #line 891 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
     break;
   case 198:
+    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+  case 201:
 /* Line 1806 of yacc.c  */
 #line 893 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-  case 199:
-/* Line 1806 of yacc.c  */
-#line 895 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-  case 200:
-/* Line 1806 of yacc.c  */
-#line 897 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-  case 201:
-/* Line 1806 of yacc.c  */
-#line 899 "parser.yy"
     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 904 "parser.yy"
+#line 898 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 906 "parser.yy"
+#line 900 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 908 "parser.yy"
+#line 902 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 909 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+  case 207:
+/* Line 1806 of yacc.c  */
+#line 911 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
+    break;
+  case 208:
+/* Line 1806 of yacc.c  */
+#line 913 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+  case 209:
+/* Line 1806 of yacc.c  */
 #line 915 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
-    break;
-  case 207:
-/* Line 1806 of yacc.c  */
-#line 917 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     break;
-  case 208:
-/* Line 1806 of yacc.c  */
-#line 919 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
-    break;
-  case 209:
-/* Line 1806 of yacc.c  */
-#line 921 "parser.yy"
-    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
-    break;
   case 210:
 /* Line 1806 of yacc.c  */
+#line 920 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+  case 211:
+/* Line 1806 of yacc.c  */
+#line 922 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
+    break;
+  case 212:
+/* Line 1806 of yacc.c  */
+#line 924 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+  case 213:
+/* Line 1806 of yacc.c  */
 #line 926 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
-    break;
-  case 211:
-/* Line 1806 of yacc.c  */
-#line 928 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     break;
-  case 212:
-/* Line 1806 of yacc.c  */
-#line 930 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
-    break;
-  case 213:
-/* Line 1806 of yacc.c  */
-#line 932 "parser.yy"
-    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
-    break;
   case 214:
 /* Line 1806 of yacc.c  */
 #line 937 "parser.yy"
+#line 931 "parser.yy"
+    {
                         (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
 …
 /* Line 1806 of yacc.c  */
 #line 950 "parser.yy"
+#line 944 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 955 "parser.yy"
+#line 949 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 957 "parser.yy"
+#line 951 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
+#line 960 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
+    break;
+  case 221:
+/* Line 1806 of yacc.c  */
+#line 962 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
+    break;
+  case 222:
+/* Line 1806 of yacc.c  */
+#line 964 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
+    break;
+  case 223:
+/* Line 1806 of yacc.c  */
 #line 966 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
     break;
   case 221:
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
+    break;
+  case 224:
 /* Line 1806 of yacc.c  */
 #line 968 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
-    break;
-  case 222:
-/* Line 1806 of yacc.c  */
-#line 970 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
-    break;
-  case 223:
-/* Line 1806 of yacc.c  */
-#line 972 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
-    break;
-  case 224:
-/* Line 1806 of yacc.c  */
-#line 974 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 979 "parser.yy"
+#line 973 "parser.yy"
     { (yyval.flag) = false; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 981 "parser.yy"
+#line 975 "parser.yy"
     { (yyval.flag) = true; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 986 "parser.yy"
+#line 980 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 993 "parser.yy"
+#line 987 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 998 "parser.yy"
+#line 992 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1000 "parser.yy"
+#line 994 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1005 "parser.yy"
+#line 999 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1007 "parser.yy"
+#line 1001 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1009 "parser.yy"
+#line 1003 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1014 "parser.yy"
+#line 1008 "parser.yy"
+    {
                         (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1019 "parser.yy"
+#line 1013 "parser.yy"
+    {
                         (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1029 "parser.yy"
+#line 1023 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1036 "parser.yy"
+#line 1030 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1041 "parser.yy"
+#line 1035 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1048 "parser.yy"
+#line 1042 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1062 "parser.yy"
+#line 1056 "parser.yy"
     {}
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1063 "parser.yy"
+#line 1057 "parser.yy"
     {}
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1092 "parser.yy"
+#line 1086 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1099 "parser.yy"
+#line 1093 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1104 "parser.yy"
+#line 1098 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1114 "parser.yy"
+#line 1108 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1119 "parser.yy"
+#line 1113 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1124 "parser.yy"
+#line 1118 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1132 "parser.yy"
+#line 1126 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1137 "parser.yy"
+#line 1131 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1142 "parser.yy"
+#line 1136 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1147 "parser.yy"
+#line 1141 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1152 "parser.yy"
+#line 1146 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1183 "parser.yy"
+#line 1177 "parser.yy"
+    {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
 …
 /* Line 1806 of yacc.c  */
 #line 1187 "parser.yy"
+#line 1181 "parser.yy"
+    {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
 …
 /* Line 1806 of yacc.c  */
 #line 1194 "parser.yy"
+#line 1188 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1198 "parser.yy"
+#line 1192 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1203 "parser.yy"
+#line 1197 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1208 "parser.yy"
+#line 1202 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1213 "parser.yy"
+#line 1207 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1224 "parser.yy"
+#line 1218 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1229 "parser.yy"
+#line 1223 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1234 "parser.yy"
+#line 1228 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1239 "parser.yy"
+#line 1233 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1244 "parser.yy"
+#line 1238 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1253 "parser.yy"
+#line 1247 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1258 "parser.yy"
+#line 1252 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1275 "parser.yy"
+#line 1269 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1280 "parser.yy"
+#line 1274 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1302 "parser.yy"
+#line 1296 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1314 "parser.yy"
+#line 1308 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1319 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+    break;
+  case 305:
+/* Line 1806 of yacc.c  */
+#line 1321 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+    break;
+  case 306:
+/* Line 1806 of yacc.c  */
+#line 1323 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+    break;
+  case 307:
+/* Line 1806 of yacc.c  */
 #line 1325 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     break;
   case 305:
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+    break;
+  case 308:
 /* Line 1806 of yacc.c  */
 #line 1327 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     break;
   case 306:
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+    break;
+  case 309:
 /* Line 1806 of yacc.c  */
 #line 1329 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
-    break;
-  case 307:
-/* Line 1806 of yacc.c  */
-#line 1331 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
-    break;
-  case 308:
-/* Line 1806 of yacc.c  */
-#line 1333 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
-    break;
-  case 309:
-/* Line 1806 of yacc.c  */
-#line 1335 "parser.yy"
+    {
                         typedefTable.enterScope();
 …
 /* Line 1806 of yacc.c  */
 #line 1339 "parser.yy"
+#line 1333 "parser.yy"
+    {
                         typedefTable.leaveScope();
 …
 /* Line 1806 of yacc.c  */
 #line 1348 "parser.yy"
+#line 1342 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1350 "parser.yy"
+#line 1344 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1361 "parser.yy"
+#line 1355 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1360 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
+    break;
+  case 317:
+/* Line 1806 of yacc.c  */
+#line 1362 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
+    break;
+  case 318:
+/* Line 1806 of yacc.c  */
+#line 1364 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
+    break;
+  case 319:
+/* Line 1806 of yacc.c  */
 #line 1366 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
-    break;
-  case 317:
-/* Line 1806 of yacc.c  */
-#line 1368 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
-    break;
-  case 318:
-/* Line 1806 of yacc.c  */
-#line 1370 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
-    break;
-  case 319:
-/* Line 1806 of yacc.c  */
-#line 1372 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1375 "parser.yy"
+#line 1369 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1377 "parser.yy"
+#line 1371 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1380 "parser.yy"
+#line 1374 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1382 "parser.yy"
+#line 1376 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1381 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+    break;
+  case 325:
+/* Line 1806 of yacc.c  */
+#line 1383 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+    break;
+  case 326:
+/* Line 1806 of yacc.c  */
+#line 1385 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+    break;
+  case 327:
+/* Line 1806 of yacc.c  */
 #line 1387 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+    break;
+  case 328:
+/* Line 1806 of yacc.c  */
+#line 1389 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
+    break;
+  case 329:
+/* Line 1806 of yacc.c  */
+#line 1391 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
+    break;
+  case 330:
+/* Line 1806 of yacc.c  */
+#line 1393 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
+    break;
+  case 331:
+/* Line 1806 of yacc.c  */
+#line 1395 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+    break;
+  case 332:
+/* Line 1806 of yacc.c  */
+#line 1397 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+    break;
+  case 333:
+/* Line 1806 of yacc.c  */
+#line 1399 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+    break;
+  case 334:
+/* Line 1806 of yacc.c  */
+#line 1401 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+    break;
+  case 335:
+/* Line 1806 of yacc.c  */
+#line 1403 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+    break;
+  case 336:
+/* Line 1806 of yacc.c  */
+#line 1405 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+    break;
+  case 337:
+/* Line 1806 of yacc.c  */
+#line 1407 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
+  case 325:
+/* Line 1806 of yacc.c  */
+#line 1389 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+    break;
+  case 326:
+/* Line 1806 of yacc.c  */
+#line 1391 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+    break;
+  case 327:
+/* Line 1806 of yacc.c  */
+#line 1393 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+    break;
+  case 328:
+/* Line 1806 of yacc.c  */
+#line 1395 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
+    break;
+  case 329:
+/* Line 1806 of yacc.c  */
+#line 1397 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
+    break;
+  case 330:
+/* Line 1806 of yacc.c  */
+#line 1399 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
+    break;
+  case 331:
+/* Line 1806 of yacc.c  */
+#line 1401 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+    break;
+  case 332:
+/* Line 1806 of yacc.c  */
+#line 1403 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+    break;
+  case 333:
+/* Line 1806 of yacc.c  */
+#line 1405 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+    break;
+  case 334:
+/* Line 1806 of yacc.c  */
+#line 1407 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+    break;
+  case 335:
+  case 338:
 /* Line 1806 of yacc.c  */
 #line 1409 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
-    break;
-  case 336:
-/* Line 1806 of yacc.c  */
-#line 1411 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
-    break;
-  case 337:
-/* Line 1806 of yacc.c  */
-#line 1413 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
-  case 338:
-/* Line 1806 of yacc.c  */
-#line 1415 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
-    break;
   case 340:
 /* Line 1806 of yacc.c  */
+#line 1416 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 341:
+/* Line 1806 of yacc.c  */
+#line 1418 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 342:
+/* Line 1806 of yacc.c  */
+#line 1420 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+  case 343:
+/* Line 1806 of yacc.c  */
 #line 1422 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
+    break;
+  case 345:
+/* Line 1806 of yacc.c  */
+#line 1428 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+  case 347:
+/* Line 1806 of yacc.c  */
+#line 1435 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
   case 341:
 /* Line 1806 of yacc.c  */
 #line 1424 "parser.yy"
+  case 348:
+/* Line 1806 of yacc.c  */
+#line 1437 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
+  case 342:
+/* Line 1806 of yacc.c  */
+#line 1426 "parser.yy"
+  case 349:
+/* Line 1806 of yacc.c  */
+#line 1439 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 350:
+/* Line 1806 of yacc.c  */
+#line 1444 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
+    break;
+  case 351:
+/* Line 1806 of yacc.c  */
+#line 1446 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
+    break;
+  case 352:
+/* Line 1806 of yacc.c  */
+#line 1448 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
+    break;
+  case 353:
+/* Line 1806 of yacc.c  */
+#line 1450 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+  case 355:
+/* Line 1806 of yacc.c  */
+#line 1456 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 356:
+/* Line 1806 of yacc.c  */
+#line 1458 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 357:
+/* Line 1806 of yacc.c  */
+#line 1460 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
+  case 343:
+/* Line 1806 of yacc.c  */
+#line 1428 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
+    break;
+  case 345:
+/* Line 1806 of yacc.c  */
+#line 1434 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+  case 347:
+/* Line 1806 of yacc.c  */
+#line 1441 "parser.yy"
+  case 359:
+/* Line 1806 of yacc.c  */
+#line 1466 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
   case 348:
 /* Line 1806 of yacc.c  */
 #line 1443 "parser.yy"
+  case 360:
+/* Line 1806 of yacc.c  */
+#line 1468 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
+  case 349:
+/* Line 1806 of yacc.c  */
+#line 1445 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 350:
+/* Line 1806 of yacc.c  */
+#line 1450 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
+    break;
+  case 351:
+/* Line 1806 of yacc.c  */
+#line 1452 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
+    break;
+  case 352:
+/* Line 1806 of yacc.c  */
+#line 1454 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
+    break;
+  case 353:
+/* Line 1806 of yacc.c  */
+#line 1456 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+  case 355:
+/* Line 1806 of yacc.c  */
+#line 1462 "parser.yy"
+  case 362:
+/* Line 1806 of yacc.c  */
+#line 1474 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
   case 356:
 /* Line 1806 of yacc.c  */
 #line 1464 "parser.yy"
+  case 363:
+/* Line 1806 of yacc.c  */
+#line 1476 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 357:
 /* Line 1806 of yacc.c  */
 #line 1466 "parser.yy"
+  case 364:
+/* Line 1806 of yacc.c  */
+#line 1478 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
+  case 359:
+/* Line 1806 of yacc.c  */
+#line 1472 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 360:
+/* Line 1806 of yacc.c  */
+#line 1474 "parser.yy"
+  case 365:
+/* Line 1806 of yacc.c  */
+#line 1483 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
+    break;
+  case 366:
+/* Line 1806 of yacc.c  */
+#line 1485 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 367:
+/* Line 1806 of yacc.c  */
+#line 1487 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
-  case 362:
-/* Line 1806 of yacc.c  */
-#line 1480 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-  case 363:
-/* Line 1806 of yacc.c  */
-#line 1482 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 364:
-/* Line 1806 of yacc.c  */
-#line 1484 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-  case 365:
-/* Line 1806 of yacc.c  */
-#line 1489 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
-    break;
-  case 366:
-/* Line 1806 of yacc.c  */
-#line 1491 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-  case 367:
-/* Line 1806 of yacc.c  */
-#line 1493 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
   case 370:
 /* Line 1806 of yacc.c  */
 #line 1503 "parser.yy"
+#line 1497 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1505 "parser.yy"
+#line 1499 "parser.yy"
+    {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
 …
 /* Line 1806 of yacc.c  */
+#line 1504 "parser.yy"
+    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
+    break;
+  case 373:
+/* Line 1806 of yacc.c  */
+#line 1506 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
+    break;
+  case 374:
+/* Line 1806 of yacc.c  */
+#line 1508 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
+    break;
+  case 375:
+/* Line 1806 of yacc.c  */
 #line 1510 "parser.yy"
-    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
-    break;
-  case 373:
-/* Line 1806 of yacc.c  */
-#line 1512 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
-    break;
-  case 374:
-/* Line 1806 of yacc.c  */
-#line 1514 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
-    break;
-  case 375:
-/* Line 1806 of yacc.c  */
-#line 1516 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1521 "parser.yy"
+#line 1515 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Struct; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1523 "parser.yy"
+#line 1517 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Union; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1528 "parser.yy"
+#line 1522 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1524 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
+    break;
+  case 381:
+/* Line 1806 of yacc.c  */
 #line 1530 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
-    break;
-  case 381:
-/* Line 1806 of yacc.c  */
-#line 1536 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1539 "parser.yy"
+#line 1533 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
 …
 /* Line 1806 of yacc.c  */
 #line 1549 "parser.yy"
+#line 1543 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1551 "parser.yy"
+#line 1545 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1553 "parser.yy"
+#line 1547 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1558 "parser.yy"
+#line 1552 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1560 "parser.yy"
+#line 1554 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1565 "parser.yy"
+#line 1559 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1561 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
+    break;
+  case 392:
+/* Line 1806 of yacc.c  */
+#line 1564 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
+    break;
+  case 393:
+/* Line 1806 of yacc.c  */
 #line 1567 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
-    break;
-  case 392:
-/* Line 1806 of yacc.c  */
-#line 1570 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
   case 393:
+  case 395:
 /* Line 1806 of yacc.c  */
 #line 1573 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
-    break;
-  case 395:
-/* Line 1806 of yacc.c  */
-#line 1579 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1581 "parser.yy"
+#line 1575 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1586 "parser.yy"
+#line 1580 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1595 "parser.yy"
+#line 1589 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1597 "parser.yy"
+#line 1591 "parser.yy"
+    {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1602 "parser.yy"
+#line 1596 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1604 "parser.yy"
+#line 1598 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1609 "parser.yy"
+#line 1603 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1611 "parser.yy"
+#line 1605 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1616 "parser.yy"
+#line 1610 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1618 "parser.yy"
+#line 1612 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1625 "parser.yy"
+#line 1619 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1633 "parser.yy"
+#line 1627 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1635 "parser.yy"
+#line 1629 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1637 "parser.yy"
+#line 1631 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1645 "parser.yy"
+#line 1639 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1647 "parser.yy"
+#line 1641 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1643 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
+    break;
+  case 419:
+/* Line 1806 of yacc.c  */
 #line 1649 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
-    break;
-  case 419:
-/* Line 1806 of yacc.c  */
-#line 1655 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1660 "parser.yy"
+#line 1654 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1667 "parser.yy"
+#line 1661 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1674 "parser.yy"
+#line 1668 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1676 "parser.yy"
+#line 1670 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1685 "parser.yy"
+#line 1679 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1688 "parser.yy"
+#line 1682 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1690 "parser.yy"
+#line 1684 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1694 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 438:
+/* Line 1806 of yacc.c  */
 #line 1700 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-  case 438:
-/* Line 1806 of yacc.c  */
-#line 1706 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1711 "parser.yy"
+#line 1705 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1720 "parser.yy"
+#line 1714 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1729 "parser.yy"
+#line 1723 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1731 "parser.yy"
+#line 1725 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1756 "parser.yy"
+#line 1750 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1764 "parser.yy"
+#line 1758 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1769 "parser.yy"
+#line 1763 "parser.yy"
     { (yyval.in) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1765 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in); }
+    break;
+  case 462:
+/* Line 1806 of yacc.c  */
+#line 1767 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
+    break;
+  case 463:
+/* Line 1806 of yacc.c  */
 #line 1771 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in); }
     break;
   case 462:
 /* Line 1806 of yacc.c  */
 #line 1773 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     break;
   case 463:
+    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
+    break;
+  case 464:
+/* Line 1806 of yacc.c  */
+#line 1772 "parser.yy"
+    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
+    break;
+  case 465:
 /* Line 1806 of yacc.c  */
 #line 1777 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
-    break;
-  case 464:
-/* Line 1806 of yacc.c  */
-#line 1778 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
-    break;
-  case 465:
-/* Line 1806 of yacc.c  */
-#line 1783 "parser.yy"
     { (yyval.in) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1785 "parser.yy"
+#line 1779 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1786 "parser.yy"
+#line 1780 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1788 "parser.yy"
+#line 1782 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1798 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
+    break;
+  case 473:
+/* Line 1806 of yacc.c  */
 #line 1804 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     break;
   case 473:
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+  case 474:
 /* Line 1806 of yacc.c  */
 #line 1810 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
-    break;
-  case 474:
-/* Line 1806 of yacc.c  */
-#line 1816 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1813 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+  case 476:
+/* Line 1806 of yacc.c  */
+#line 1815 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+  case 477:
+/* Line 1806 of yacc.c  */
+#line 1817 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
+    break;
+  case 478:
+/* Line 1806 of yacc.c  */
 #line 1819 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-  case 476:
-/* Line 1806 of yacc.c  */
-#line 1821 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-  case 477:
-/* Line 1806 of yacc.c  */
-#line 1823 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
-    break;
-  case 478:
-/* Line 1806 of yacc.c  */
-#line 1825 "parser.yy"
     { (yyval.en) = (yyvsp[(4) - (6)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1849 "parser.yy"
+#line 1843 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1851 "parser.yy"
+#line 1845 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1847 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+  case 484:
+/* Line 1806 of yacc.c  */
 #line 1853 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-  case 484:
-/* Line 1806 of yacc.c  */
-#line 1859 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1861 "parser.yy"
+#line 1855 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1860 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+  case 488:
+/* Line 1806 of yacc.c  */
 #line 1866 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-  case 488:
-/* Line 1806 of yacc.c  */
-#line 1872 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1877 "parser.yy"
+#line 1871 "parser.yy"
     { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 1873 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 492:
+/* Line 1806 of yacc.c  */
 #line 1879 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 492:
-/* Line 1806 of yacc.c  */
-#line 1885 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Otype; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1887 "parser.yy"
+#line 1881 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ftype; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1889 "parser.yy"
+#line 1883 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Dtype; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1894 "parser.yy"
+#line 1888 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1896 "parser.yy"
+#line 1890 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1901 "parser.yy"
+#line 1895 "parser.yy"
+    {
                         typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1906 "parser.yy"
+#line 1900 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1908 "parser.yy"
+#line 1902 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1913 "parser.yy"
+#line 1907 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1916 "parser.yy"
+#line 1910 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1918 "parser.yy"
+#line 1912 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1923 "parser.yy"
+#line 1917 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1925 "parser.yy"
+#line 1919 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1927 "parser.yy"
+#line 1921 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1932 "parser.yy"
+#line 1926 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1934 "parser.yy"
+#line 1928 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1939 "parser.yy"
+#line 1933 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
 …
 /* Line 1806 of yacc.c  */
 #line 1944 "parser.yy"
+#line 1938 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
 …
 /* Line 1806 of yacc.c  */
 #line 1952 "parser.yy"
+#line 1946 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1957 "parser.yy"
+#line 1951 "parser.yy"
+    {
                         typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 1962 "parser.yy"
+#line 1956 "parser.yy"
+    {
                         typedefTable.leaveTrait();
 …
 /* Line 1806 of yacc.c  */
 #line 1972 "parser.yy"
+#line 1966 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 1982 "parser.yy"
+#line 1976 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1987 "parser.yy"
+#line 1981 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 1992 "parser.yy"
+#line 1986 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2000 "parser.yy"
+#line 1994 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2005 "parser.yy"
+#line 1999 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2015 "parser.yy"
+#line 2009 "parser.yy"
     {}
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2011 "parser.yy"
+    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
+    break;
+  case 526:
+/* Line 1806 of yacc.c  */
 #line 2017 "parser.yy"
-    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
-    break;
-  case 526:
-/* Line 1806 of yacc.c  */
-#line 2023 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2028 "parser.yy"
+#line 2022 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2036 "parser.yy"
+#line 2030 "parser.yy"
     {}
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2038 "parser.yy"
+#line 2032 "parser.yy"
+    {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
 …
 /* Line 1806 of yacc.c  */
 #line 2043 "parser.yy"
+#line 2037 "parser.yy"
+    {
                         linkage = linkageStack.top();
 …
 /* Line 1806 of yacc.c  */
 #line 2049 "parser.yy"
+#line 2043 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
 …
 /* Line 1806 of yacc.c  */
 #line 2064 "parser.yy"
+#line 2058 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2070 "parser.yy"
+#line 2064 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2079 "parser.yy"
+#line 2073 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2085 "parser.yy"
+#line 2079 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
   case 540:
+/* Line 1806 of yacc.c  */
+#line 2085 "parser.yy"
+    {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
+                }
+    break;
+  case 541:
 /* Line 1806 of yacc.c  */
 …
     break;
   case 541:
+  case 542:
 /* Line 1806 of yacc.c  */
 #line 2097 "parser.yy"
+    {
-                        typedefTable.addToEnclosingScope( TypedefTable::ID );
-                        typedefTable.leaveScope();
-                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
+                }
-    break;
-  case 542:
-/* Line 1806 of yacc.c  */
-#line 2103 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2111 "parser.yy"
+#line 2105 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2117 "parser.yy"
+#line 2111 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2125 "parser.yy"
+#line 2119 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2131 "parser.yy"
+#line 2125 "parser.yy"
+    {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
 …
 /* Line 1806 of yacc.c  */
 #line 2146 "parser.yy"
+#line 2140 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2151 "parser.yy"
+#line 2145 "parser.yy"
     { delete (yyvsp[(3) - (5)].str); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2156 "parser.yy"
+#line 2150 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2157 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 557:
+/* Line 1806 of yacc.c  */
 #line 2163 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-  case 557:
-/* Line 1806 of yacc.c  */
-#line 2169 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2174 "parser.yy"
+    { delete (yyvsp[(3) - (4)].en); }
+    break;
+  case 563:
+/* Line 1806 of yacc.c  */
+#line 2178 "parser.yy"
+    { delete (yyvsp[(1) - (1)].tok); }
+    break;
+  case 564:
+/* Line 1806 of yacc.c  */
+#line 2179 "parser.yy"
+    { delete (yyvsp[(1) - (1)].decl); }
+    break;
+  case 565:
+/* Line 1806 of yacc.c  */
 #line 2180 "parser.yy"
-    { delete (yyvsp[(3) - (4)].en); }
-    break;
-  case 563:
-/* Line 1806 of yacc.c  */
-#line 2184 "parser.yy"
-    { delete (yyvsp[(1) - (1)].tok); }
-    break;
-  case 564:
-/* Line 1806 of yacc.c  */
-#line 2185 "parser.yy"
     { delete (yyvsp[(1) - (1)].decl); }
     break;
   case 565:
 /* Line 1806 of yacc.c  */
 #line 2186 "parser.yy"
+  case 566:
+/* Line 1806 of yacc.c  */
+#line 2181 "parser.yy"
     { delete (yyvsp[(1) - (1)].decl); }
     break;
-  case 566:
-/* Line 1806 of yacc.c  */
-#line 2187 "parser.yy"
-    { delete (yyvsp[(1) - (1)].decl); }
-    break;
   case 567:
 /* Line 1806 of yacc.c  */
 #line 2222 "parser.yy"
+#line 2216 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2225 "parser.yy"
+#line 2219 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2227 "parser.yy"
+#line 2221 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2232 "parser.yy"
+#line 2226 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 2237 "parser.yy"
+#line 2231 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2242 "parser.yy"
+#line 2236 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2244 "parser.yy"
+#line 2238 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2246 "parser.yy"
+#line 2240 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2245 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 577:
+/* Line 1806 of yacc.c  */
+#line 2247 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 578:
+/* Line 1806 of yacc.c  */
+#line 2249 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 579:
+/* Line 1806 of yacc.c  */
 #line 2251 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 580:
+/* Line 1806 of yacc.c  */
+#line 2256 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+  case 581:
+/* Line 1806 of yacc.c  */
+#line 2258 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 582:
+/* Line 1806 of yacc.c  */
+#line 2267 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 584:
+/* Line 1806 of yacc.c  */
+#line 2270 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 585:
+/* Line 1806 of yacc.c  */
+#line 2275 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+  case 586:
+/* Line 1806 of yacc.c  */
+#line 2277 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+  case 587:
+/* Line 1806 of yacc.c  */
+#line 2279 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 588:
+/* Line 1806 of yacc.c  */
+#line 2284 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 589:
+/* Line 1806 of yacc.c  */
+#line 2286 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 590:
+/* Line 1806 of yacc.c  */
+#line 2288 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 591:
+/* Line 1806 of yacc.c  */
+#line 2293 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 592:
+/* Line 1806 of yacc.c  */
+#line 2295 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 593:
+/* Line 1806 of yacc.c  */
+#line 2297 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 597:
+/* Line 1806 of yacc.c  */
+#line 2312 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
+    break;
+  case 598:
+/* Line 1806 of yacc.c  */
+#line 2314 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
+    break;
+  case 599:
+/* Line 1806 of yacc.c  */
+#line 2316 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 600:
+/* Line 1806 of yacc.c  */
+#line 2321 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 601:
+/* Line 1806 of yacc.c  */
+#line 2323 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 602:
+/* Line 1806 of yacc.c  */
+#line 2325 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 603:
+/* Line 1806 of yacc.c  */
+#line 2330 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 604:
+/* Line 1806 of yacc.c  */
+#line 2332 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 605:
+/* Line 1806 of yacc.c  */
+#line 2334 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 606:
+/* Line 1806 of yacc.c  */
+#line 2349 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 608:
+/* Line 1806 of yacc.c  */
+#line 2352 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 609:
+/* Line 1806 of yacc.c  */
+#line 2354 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 611:
+/* Line 1806 of yacc.c  */
+#line 2360 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 612:
+/* Line 1806 of yacc.c  */
+#line 2365 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 613:
+/* Line 1806 of yacc.c  */
+#line 2367 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 614:
+/* Line 1806 of yacc.c  */
+#line 2369 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 615:
+/* Line 1806 of yacc.c  */
+#line 2374 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 577:
 /* Line 1806 of yacc.c  */
 #line 2253 "parser.yy"
+  case 616:
+/* Line 1806 of yacc.c  */
+#line 2376 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 578:
 /* Line 1806 of yacc.c  */
 #line 2255 "parser.yy"
+  case 617:
+/* Line 1806 of yacc.c  */
+#line 2378 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 579:
 /* Line 1806 of yacc.c  */
 #line 2257 "parser.yy"
+  case 618:
+/* Line 1806 of yacc.c  */
+#line 2380 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
+  case 580:
+/* Line 1806 of yacc.c  */
+#line 2262 "parser.yy"
+  case 619:
+/* Line 1806 of yacc.c  */
+#line 2385 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+  case 620:
+/* Line 1806 of yacc.c  */
+#line 2387 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
   case 581:
 /* Line 1806 of yacc.c  */
 #line 2264 "parser.yy"
+  case 621:
+/* Line 1806 of yacc.c  */
+#line 2389 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
   case 582:
 /* Line 1806 of yacc.c  */
 #line 2273 "parser.yy"
+  case 622:
+/* Line 1806 of yacc.c  */
+#line 2399 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 584:
 /* Line 1806 of yacc.c  */
 #line 2276 "parser.yy"
+  case 624:
+/* Line 1806 of yacc.c  */
+#line 2402 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
+  case 585:
+/* Line 1806 of yacc.c  */
+#line 2281 "parser.yy"
+  case 625:
+/* Line 1806 of yacc.c  */
+#line 2404 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 626:
+/* Line 1806 of yacc.c  */
+#line 2409 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 627:
+/* Line 1806 of yacc.c  */
+#line 2411 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 628:
+/* Line 1806 of yacc.c  */
+#line 2413 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 629:
+/* Line 1806 of yacc.c  */
+#line 2418 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 630:
+/* Line 1806 of yacc.c  */
+#line 2420 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 631:
+/* Line 1806 of yacc.c  */
+#line 2422 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 632:
+/* Line 1806 of yacc.c  */
+#line 2424 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 633:
+/* Line 1806 of yacc.c  */
+#line 2429 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
   case 586:
 /* Line 1806 of yacc.c  */
 #line 2283 "parser.yy"
+  case 634:
+/* Line 1806 of yacc.c  */
+#line 2431 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
   case 587:
 /* Line 1806 of yacc.c  */
 #line 2285 "parser.yy"
+  case 635:
+/* Line 1806 of yacc.c  */
+#line 2433 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
+  case 588:
+/* Line 1806 of yacc.c  */
+#line 2290 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 589:
+/* Line 1806 of yacc.c  */
+#line 2292 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 590:
+/* Line 1806 of yacc.c  */
+#line 2294 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 591:
+/* Line 1806 of yacc.c  */
+#line 2299 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 592:
+/* Line 1806 of yacc.c  */
+#line 2301 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 593:
+/* Line 1806 of yacc.c  */
+#line 2303 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 597:
+/* Line 1806 of yacc.c  */
+#line 2318 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
+    break;
+  case 598:
+/* Line 1806 of yacc.c  */
+#line 2320 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
+    break;
+  case 599:
+/* Line 1806 of yacc.c  */
+#line 2322 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 600:
+/* Line 1806 of yacc.c  */
+#line 2327 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 601:
+/* Line 1806 of yacc.c  */
+#line 2329 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 602:
+/* Line 1806 of yacc.c  */
+#line 2331 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 603:
+/* Line 1806 of yacc.c  */
+#line 2336 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 604:
+/* Line 1806 of yacc.c  */
+#line 2338 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 605:
+/* Line 1806 of yacc.c  */
+#line 2340 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 606:
+/* Line 1806 of yacc.c  */
+#line 2355 "parser.yy"
+  case 636:
+/* Line 1806 of yacc.c  */
+#line 2464 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 608:
 /* Line 1806 of yacc.c  */
 #line 2358 "parser.yy"
+  case 638:
+/* Line 1806 of yacc.c  */
+#line 2467 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 609:
 /* Line 1806 of yacc.c  */
 #line 2360 "parser.yy"
+  case 639:
+/* Line 1806 of yacc.c  */
+#line 2469 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
-  case 611:
-/* Line 1806 of yacc.c  */
-#line 2366 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 612:
-/* Line 1806 of yacc.c  */
-#line 2371 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-  case 613:
-/* Line 1806 of yacc.c  */
-#line 2373 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-  case 614:
-/* Line 1806 of yacc.c  */
-#line 2375 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 615:
-/* Line 1806 of yacc.c  */
-#line 2380 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 616:
-/* Line 1806 of yacc.c  */
-#line 2382 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 617:
-/* Line 1806 of yacc.c  */
-#line 2384 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 618:
-/* Line 1806 of yacc.c  */
-#line 2386 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 619:
-/* Line 1806 of yacc.c  */
-#line 2391 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-  case 620:
-/* Line 1806 of yacc.c  */
-#line 2393 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-  case 621:
-/* Line 1806 of yacc.c  */
-#line 2395 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 622:
-/* Line 1806 of yacc.c  */
-#line 2405 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 624:
-/* Line 1806 of yacc.c  */
-#line 2408 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 625:
-/* Line 1806 of yacc.c  */
-#line 2410 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 626:
-/* Line 1806 of yacc.c  */
-#line 2415 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-  case 627:
-/* Line 1806 of yacc.c  */
-#line 2417 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-  case 628:
-/* Line 1806 of yacc.c  */
-#line 2419 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 629:
-/* Line 1806 of yacc.c  */
-#line 2424 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 630:
-/* Line 1806 of yacc.c  */
-#line 2426 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 631:
-/* Line 1806 of yacc.c  */
-#line 2428 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 632:
-/* Line 1806 of yacc.c  */
-#line 2430 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 633:
-/* Line 1806 of yacc.c  */
-#line 2435 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-  case 634:
-/* Line 1806 of yacc.c  */
-#line 2437 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-  case 635:
-/* Line 1806 of yacc.c  */
-#line 2439 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 636:
-/* Line 1806 of yacc.c  */
-#line 2470 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 638:
-/* Line 1806 of yacc.c  */
-#line 2473 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 639:
-/* Line 1806 of yacc.c  */
-#line 2475 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
   case 640:
 /* Line 1806 of yacc.c  */
 #line 2480 "parser.yy"
+#line 2474 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 2485 "parser.yy"
+#line 2479 "parser.yy"
+    {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
 …
 /* Line 1806 of yacc.c  */
 #line 2493 "parser.yy"
+#line 2487 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2495 "parser.yy"
+#line 2489 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2497 "parser.yy"
+#line 2491 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2502 "parser.yy"
+#line 2496 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2504 "parser.yy"
+#line 2498 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2509 "parser.yy"
+#line 2503 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2511 "parser.yy"
+#line 2505 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2526 "parser.yy"
+#line 2520 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2528 "parser.yy"
+#line 2522 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2527 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
+    break;
+  case 653:
+/* Line 1806 of yacc.c  */
+#line 2529 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 654:
+/* Line 1806 of yacc.c  */
+#line 2531 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 655:
+/* Line 1806 of yacc.c  */
 #line 2533 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+  case 656:
+/* Line 1806 of yacc.c  */
+#line 2535 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 658:
+/* Line 1806 of yacc.c  */
+#line 2541 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 659:
+/* Line 1806 of yacc.c  */
+#line 2543 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+  case 660:
+/* Line 1806 of yacc.c  */
+#line 2545 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 661:
+/* Line 1806 of yacc.c  */
+#line 2550 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
+    break;
+  case 662:
+/* Line 1806 of yacc.c  */
+#line 2552 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+  case 663:
+/* Line 1806 of yacc.c  */
+#line 2554 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+  case 664:
+/* Line 1806 of yacc.c  */
+#line 2560 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
+    break;
+  case 665:
+/* Line 1806 of yacc.c  */
+#line 2562 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
+    break;
+  case 667:
+/* Line 1806 of yacc.c  */
+#line 2568 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
+    break;
+  case 668:
+/* Line 1806 of yacc.c  */
+#line 2570 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
+    break;
+  case 669:
+/* Line 1806 of yacc.c  */
+#line 2572 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
+    break;
+  case 670:
+/* Line 1806 of yacc.c  */
+#line 2574 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
+    break;
+  case 672:
+/* Line 1806 of yacc.c  */
+#line 2589 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 673:
+/* Line 1806 of yacc.c  */
+#line 2591 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 674:
+/* Line 1806 of yacc.c  */
+#line 2596 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
   case 653:
 /* Line 1806 of yacc.c  */
 #line 2535 "parser.yy"
+  case 675:
+/* Line 1806 of yacc.c  */
+#line 2598 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 654:
 /* Line 1806 of yacc.c  */
 #line 2537 "parser.yy"
+  case 676:
+/* Line 1806 of yacc.c  */
+#line 2600 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
   case 655:
 /* Line 1806 of yacc.c  */
 #line 2539 "parser.yy"
+  case 677:
+/* Line 1806 of yacc.c  */
+#line 2602 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
   case 656:
 /* Line 1806 of yacc.c  */
 #line 2541 "parser.yy"
+  case 678:
+/* Line 1806 of yacc.c  */
+#line 2604 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
   case 658:
 /* Line 1806 of yacc.c  */
 #line 2547 "parser.yy"
+  case 680:
+/* Line 1806 of yacc.c  */
+#line 2610 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 659:
 /* Line 1806 of yacc.c  */
 #line 2549 "parser.yy"
+  case 681:
+/* Line 1806 of yacc.c  */
+#line 2612 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 660:
 /* Line 1806 of yacc.c  */
 #line 2551 "parser.yy"
+  case 682:
+/* Line 1806 of yacc.c  */
+#line 2614 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
   case 661:
 /* Line 1806 of yacc.c  */
 #line 2556 "parser.yy"
+  case 683:
+/* Line 1806 of yacc.c  */
+#line 2619 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
     break;
   case 662:
 /* Line 1806 of yacc.c  */
 #line 2558 "parser.yy"
+  case 684:
+/* Line 1806 of yacc.c  */
+#line 2621 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
   case 663:
 /* Line 1806 of yacc.c  */
 #line 2560 "parser.yy"
+  case 685:
+/* Line 1806 of yacc.c  */
+#line 2623 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
+  case 664:
+/* Line 1806 of yacc.c  */
+#line 2566 "parser.yy"
+  case 687:
+/* Line 1806 of yacc.c  */
+#line 2630 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+  case 689:
+/* Line 1806 of yacc.c  */
+#line 2641 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
   case 665:
 /* Line 1806 of yacc.c  */
 #line 2568 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     break;
   case 667:
 /* Line 1806 of yacc.c  */
 #line 2574 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     break;
   case 668:
 /* Line 1806 of yacc.c  */
 #line 2576 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     break;
   case 669:
 /* Line 1806 of yacc.c  */
 #line 2578 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     break;
   case 670:
 /* Line 1806 of yacc.c  */
 #line 2580 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     break;
   case 672:
 /* Line 1806 of yacc.c  */
 #line 2595 "parser.yy"
+  case 690:
+/* Line 1806 of yacc.c  */
+#line 2644 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+  case 691:
+/* Line 1806 of yacc.c  */
+#line 2646 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
+    break;
+  case 692:
+/* Line 1806 of yacc.c  */
+#line 2649 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+  case 693:
+/* Line 1806 of yacc.c  */
+#line 2651 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
+    break;
+  case 694:
+/* Line 1806 of yacc.c  */
+#line 2653 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
+    break;
+  case 696:
+/* Line 1806 of yacc.c  */
+#line 2667 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 673:
 /* Line 1806 of yacc.c  */
 #line 2597 "parser.yy"
+  case 697:
+/* Line 1806 of yacc.c  */
+#line 2669 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 674:
 /* Line 1806 of yacc.c  */
 #line 2602 "parser.yy"
+  case 698:
+/* Line 1806 of yacc.c  */
+#line 2674 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
   case 675:
 /* Line 1806 of yacc.c  */
 #line 2604 "parser.yy"
+  case 699:
+/* Line 1806 of yacc.c  */
+#line 2676 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
   case 676:
 /* Line 1806 of yacc.c  */
 #line 2606 "parser.yy"
+  case 700:
+/* Line 1806 of yacc.c  */
+#line 2678 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
   case 677:
 /* Line 1806 of yacc.c  */
 #line 2608 "parser.yy"
+  case 701:
+/* Line 1806 of yacc.c  */
+#line 2680 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
   case 678:
 /* Line 1806 of yacc.c  */
 #line 2610 "parser.yy"
+  case 702:
+/* Line 1806 of yacc.c  */
+#line 2682 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
   case 680:
 /* Line 1806 of yacc.c  */
 #line 2616 "parser.yy"
+  case 704:
+/* Line 1806 of yacc.c  */
+#line 2688 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 681:
 /* Line 1806 of yacc.c  */
 #line 2618 "parser.yy"
+  case 705:
+/* Line 1806 of yacc.c  */
+#line 2690 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
   case 682:
 /* Line 1806 of yacc.c  */
 #line 2620 "parser.yy"
+  case 706:
+/* Line 1806 of yacc.c  */
+#line 2692 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
+  case 683:
+/* Line 1806 of yacc.c  */
+#line 2625 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
+    break;
+  case 684:
+/* Line 1806 of yacc.c  */
+#line 2627 "parser.yy"
+  case 707:
+/* Line 1806 of yacc.c  */
+#line 2697 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
   case 685:
 /* Line 1806 of yacc.c  */
 #line 2629 "parser.yy"
+  case 708:
+/* Line 1806 of yacc.c  */
+#line 2699 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
-  case 687:
-/* Line 1806 of yacc.c  */
-#line 2636 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 689:
-/* Line 1806 of yacc.c  */
-#line 2647 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-  case 690:
-/* Line 1806 of yacc.c  */
-#line 2650 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-  case 691:
-/* Line 1806 of yacc.c  */
-#line 2652 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
-    break;
-  case 692:
-/* Line 1806 of yacc.c  */
-#line 2655 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-  case 693:
-/* Line 1806 of yacc.c  */
-#line 2657 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
-    break;
-  case 694:
-/* Line 1806 of yacc.c  */
-#line 2659 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
-    break;
-  case 696:
-/* Line 1806 of yacc.c  */
-#line 2673 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 697:
-/* Line 1806 of yacc.c  */
-#line 2675 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 698:
-/* Line 1806 of yacc.c  */
-#line 2680 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-  case 699:
-/* Line 1806 of yacc.c  */
-#line 2682 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-  case 700:
-/* Line 1806 of yacc.c  */
-#line 2684 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-  case 701:
-/* Line 1806 of yacc.c  */
-#line 2686 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-  case 702:
-/* Line 1806 of yacc.c  */
-#line 2688 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 704:
-/* Line 1806 of yacc.c  */
-#line 2694 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 705:
-/* Line 1806 of yacc.c  */
-#line 2696 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-  case 706:
-/* Line 1806 of yacc.c  */
-#line 2698 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-  case 707:
-/* Line 1806 of yacc.c  */
-#line 2703 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-  case 708:
-/* Line 1806 of yacc.c  */
-#line 2705 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
   case 711:
 /* Line 1806 of yacc.c  */
 #line 2715 "parser.yy"
+#line 2709 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
+#line 2719 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 715:
+/* Line 1806 of yacc.c  */
+#line 2721 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 716:
+/* Line 1806 of yacc.c  */
+#line 2723 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 717:
+/* Line 1806 of yacc.c  */
 #line 2725 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 718:
+/* Line 1806 of yacc.c  */
+#line 2727 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
   case 715:
 /* Line 1806 of yacc.c  */
 #line 2727 "parser.yy"
+  case 719:
+/* Line 1806 of yacc.c  */
+#line 2729 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
-  case 716:
-/* Line 1806 of yacc.c  */
-#line 2729 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-  case 717:
-/* Line 1806 of yacc.c  */
-#line 2731 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-  case 718:
-/* Line 1806 of yacc.c  */
-#line 2733 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-  case 719:
-/* Line 1806 of yacc.c  */
-#line 2735 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
   case 720:
 /* Line 1806 of yacc.c  */
+#line 2736 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+  case 721:
+/* Line 1806 of yacc.c  */
+#line 2738 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 722:
+/* Line 1806 of yacc.c  */
+#line 2740 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+  case 723:
+/* Line 1806 of yacc.c  */
 #line 2742 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
   case 721:
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
+    break;
+  case 724:
 /* Line 1806 of yacc.c  */
 …
     break;
+  case 722:
+/* Line 1806 of yacc.c  */
+#line 2746 "parser.yy"
+  case 725:
+/* Line 1806 of yacc.c  */
+#line 2747 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+  case 726:
+/* Line 1806 of yacc.c  */
+#line 2749 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 727:
+/* Line 1806 of yacc.c  */
+#line 2751 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
   case 723:
 /* Line 1806 of yacc.c  */
 #line 2748 "parser.yy"
+  case 728:
+/* Line 1806 of yacc.c  */
+#line 2753 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     break;
+  case 724:
+/* Line 1806 of yacc.c  */
+#line 2750 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 725:
+/* Line 1806 of yacc.c  */
+#line 2753 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+  case 726:
+  case 729:
 /* Line 1806 of yacc.c  */
 …
     break;
+  case 727:
+/* Line 1806 of yacc.c  */
+#line 2757 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+  case 728:
+/* Line 1806 of yacc.c  */
+#line 2759 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
+    break;
+  case 729:
+/* Line 1806 of yacc.c  */
+#line 2761 "parser.yy"
+  case 730:
+/* Line 1806 of yacc.c  */
+#line 2760 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+  case 731:
+/* Line 1806 of yacc.c  */
+#line 2762 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+  case 732:
+/* Line 1806 of yacc.c  */
+#line 2767 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
+    break;
+  case 733:
+/* Line 1806 of yacc.c  */
+#line 2769 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
+    break;
+  case 735:
+/* Line 1806 of yacc.c  */
+#line 2796 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 739:
+/* Line 1806 of yacc.c  */
+#line 2807 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 740:
+/* Line 1806 of yacc.c  */
+#line 2809 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 741:
+/* Line 1806 of yacc.c  */
+#line 2811 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 742:
+/* Line 1806 of yacc.c  */
+#line 2813 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 743:
+/* Line 1806 of yacc.c  */
+#line 2815 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 744:
+/* Line 1806 of yacc.c  */
+#line 2817 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 745:
+/* Line 1806 of yacc.c  */
+#line 2824 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+    break;
+  case 746:
+/* Line 1806 of yacc.c  */
+#line 2826 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+    break;
+  case 747:
+/* Line 1806 of yacc.c  */
+#line 2828 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
+  case 730:
+/* Line 1806 of yacc.c  */
+#line 2766 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+  case 731:
+/* Line 1806 of yacc.c  */
+#line 2768 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+  case 732:
+/* Line 1806 of yacc.c  */
+#line 2773 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
+    break;
+  case 733:
+/* Line 1806 of yacc.c  */
+#line 2775 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
+    break;
+  case 735:
+/* Line 1806 of yacc.c  */
+#line 2802 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+  case 739:
+/* Line 1806 of yacc.c  */
+#line 2813 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 740:
+/* Line 1806 of yacc.c  */
+#line 2815 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 741:
+/* Line 1806 of yacc.c  */
+#line 2817 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 742:
+/* Line 1806 of yacc.c  */
+#line 2819 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 743:
+/* Line 1806 of yacc.c  */
+#line 2821 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+  case 744:
+/* Line 1806 of yacc.c  */
+#line 2823 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+  case 745:
+  case 748:
 /* Line 1806 of yacc.c  */
 …
     break;
   case 746:
+  case 749:
 /* Line 1806 of yacc.c  */
 …
     break;
   case 747:
+  case 750:
 /* Line 1806 of yacc.c  */
 …
     break;
-  case 748:
-/* Line 1806 of yacc.c  */
-#line 2836 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-    break;
-  case 749:
-/* Line 1806 of yacc.c  */
-#line 2838 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-    break;
-  case 750:
-/* Line 1806 of yacc.c  */
-#line 2840 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
   case 751:
 /* Line 1806 of yacc.c  */
 #line 2845 "parser.yy"
+#line 2839 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2852 "parser.yy"
+#line 2846 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2854 "parser.yy"
+#line 2848 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2878 "parser.yy"
+#line 2872 "parser.yy"
     { (yyval.en) = 0; }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 2880 "parser.yy"
+#line 2874 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
 …
 /* Line 1806 of yacc.c  */
 #line 9184 "Parser/parser.cc"
+#line 9153 "Parser/parser.cc"
       default: break;
+    }
 …
 /* Line 2067 of yacc.c  */
 #line 2883 "parser.yy"
+#line 2877 "parser.yy"
 // ----end of grammar----

src/Parser/parser.yy

-              r1f44196
+              r3a2128f
 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
+%type<en> field field_list field_name fraction_constants
+%type<en> field field_list
+%type<tok> field_name
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
 …
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_REALFRACTIONconstant( *$2 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
-                        { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
 …
 field:                                                                                                  // CFA, tuple field selector
         field_name
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | REALDECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $2, build_varref( $1 ) ) ); }
         | REALDECIMALconstant '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $4, build_varref( $1 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
         | field_name '.' '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
         | field_name ARROW '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
+        ;
 field_name:
         INTEGERconstant fraction_constants
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
+                { $$ = $1; }
         | FLOATINGconstant fraction_constants
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
+                { $$ = $1; }
         | no_attr_identifier fraction_constants
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) ); }
+                { $$ = $1; }
+        ;
 fraction_constants:
         // empty
-                { $$ = nullptr; }
         | fraction_constants REALFRACTIONconstant
+                {
-                        Expression * constant = build_field_name_REALFRACTIONconstant( *$2 );
-                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
+                }
+        ;

src/ResolvExpr/Alternative.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // Alternative.cc --
+// Alternative.cc --
 //
 // Author           : Richard C. Bilson
 …
 // Last Modified On : Sat May 16 23:54:23 2015
 // Update Count     : 2
 //
+//
 #include "Alternative.h"
 …
 namespace ResolvExpr {
         Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( 0 ) {}
+        Alternative::Alternative() : expr( 0 ) {}
         Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
 …
                 if ( &other == this ) return *this;
                 initialize( other, *this );
-                return *this;
+        }
-        Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( other.env ) {
-                other.expr = nullptr;
+        }
-        Alternative & Alternative::operator=( Alternative && other ) {
-                if ( &other == this )  return *this;
-                delete expr;
-                cost = other.cost;
-                cvtCost = other.cvtCost;
-                expr = other.expr;
-                env = other.env;
-                other.expr = nullptr;
                 return *this;
+        }
 …
                         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;
+                        printAll( expr->get_results(), os, indent + 4 );
+                        os << ")" << std::endl;
                 } else {
                         os << "Null expression!" << std::endl;

src/ResolvExpr/Alternative.h

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // Alternative.h --
+// Alternative.h --
 //
 // Author           : Richard C. Bilson
 …
 // Last Modified On : Sat May 16 23:54:39 2015
 // Update Count     : 2
 //
+//
 #ifndef ALTERNATIVE_H
 …
                 Alternative( const Alternative &other );
                 Alternative &operator=( const Alternative &other );
-                Alternative( Alternative && other );
-                Alternative &operator=( Alternative && other );
                 ~Alternative();
                 void initialize( const Alternative &src, Alternative &dest );
                 void print( std::ostream &os, int indent = 0 ) const;
                 Cost cost;
                 Cost cvtCost;

src/ResolvExpr/AlternativeFinder.cc

-              r1f44196
+              r3a2128f
 #include "SynTree/TypeSubstitution.h"
 #include "SymTab/Validate.h"
 #include "Tuples/Tuples.h"
 #include "Tuples/Explode.h"
+#include "Tuples/TupleAssignment.h"
+#include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
-#include "InitTweak/GenInit.h"
 #include "ResolveTypeof.h"
 …
+        }
-        Cost sumCost( const AltList &in ) {
-                Cost total;
-                for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
-                        total += i->cost;
+                }
-                return total;
+        }
         namespace {
                 void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
 …
                                 out.push_back( i->expr->clone() );
+                        }
+                }
+                Cost sumCost( const AltList &in ) {
+                        Cost total;
+                        for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
+                                total += i->cost;
+                        }
+                        return total;
+                }
 …
                                 PruneStruct current( candidate );
                                 std::string mangleName;
+                                {
                                         Type * newType = candidate->expr->get_result()->clone();
+                                for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
+                                        Type *newType = (*retType)->clone();
                                         candidate->env.apply( newType );
                                         mangleName = SymTab::Mangler::mangle( newType );
+                                        mangleName += SymTab::Mangler::mangle( newType );
                                         delete newType;
+                                }
 …
                                 if ( ! target->second.isAmbiguous ) {
                                         Alternative &alt = *target->second.candidate;
+                                        alt.env.applyFree( alt.expr->get_result() );
+                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
+                                                alt.env.applyFree( *result );
+                                        }
                                         *out++ = alt;
+                                }
+                        }
+                }
+                template< typename InputIterator, typename OutputIterator >
+                void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
+                        AltList alternatives;
+                        // select the alternatives that have the minimum parameter cost
+                        Cost minCost = Cost::infinity;
+                        for ( AltList::iterator i = begin; i != end; ++i ) {
+                                if ( i->cost < minCost ) {
+                                        minCost = i->cost;
+                                        i->cost = i->cvtCost;
+                                        alternatives.clear();
+                                        alternatives.push_back( *i );
+                                } else if ( i->cost == minCost ) {
+                                        i->cost = i->cvtCost;
+                                        alternatives.push_back( *i );
+                                }
+                        }
+                        std::copy( alternatives.begin(), alternatives.end(), out );
+                }
+                template< typename InputIterator >
+                void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
+                        while ( begin != end ) {
+                                result.simpleCombine( (*begin++).env );
+                        }
+                }
                 void renameTypes( Expression *expr ) {
+                        expr->get_result()->accept( global_renamer );
+                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                                (*i)->accept( global_renamer );
+                        }
+                }
+        }
 …
                 for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
                         if ( adjust ) {
                                 adjustExprType( i->expr->get_result(), i->env, indexer );
+                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
+                        }
+                }
 …
+        }
-        // std::unordered_map< Expression *, UniqueExpr * > ;
         template< typename StructOrUnionType >
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+                // by this point, member must be a name expr
+                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
+                const std::string & name = nameExpr->get_name();
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
 …
+        }
-        void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
-                if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
-                        // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
-                        // xxx - this should be improved by memoizing the value of constant exprs
-                        // during parsing and reusing that information here.
-                        std::stringstream ss( constantExpr->get_constant()->get_value() );
-                        int val;
-                        std::string tmp;
-                        if ( ss >> val && ! (ss >> tmp) ) {
-                                if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
-                                        alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                                } // if
-                        } // if
-                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
-                        // xxx - temporary hack until 0/1 are int constants
-                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
-                                std::stringstream ss( nameExpr->get_name() );
-                                int val;
-                                ss >> val;
-                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                        }
-                } // if
+        }
         void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
                 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
 …
         Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
+                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
+                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( alt.expr );
+                assert( appExpr );
+                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                assert( pointer );
+                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                assert( function );
                 Cost convCost( 0, 0, 0 );
 …
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
                 std::list< Expression* >& actuals = appExpr->get_args();
-                std::list< Type * > formalTypes;
-                std::list< Type * >::iterator formalType = formalTypes.end();
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
                                 (*actualExpr)->get_result()->print( std::cerr, 8 );
+                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
+                        )
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
+                        std::list< Type * > flatActualTypes;
+                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
+                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
+                                // tuple handling code
+                                if ( formalType == formalTypes.end() ) {
+                                        // the type of the formal parameter may be a tuple type. To make this easier to work with,
+                                        // flatten the tuple type and traverse the resulting list of types, incrementing the formal
+                                        // iterator once its types have been extracted. Once a particular formal parameter's type has
+                                        // been exhausted load the next formal parameter's type.
+                                        if ( formal == formals.end() ) {
+                                                if ( function->get_isVarArgs() ) {
+                                                        convCost += Cost( 1, 0, 0 );
+                                                        break;
+                                                } else {
+                                                        return Cost::infinity;
+                                                }
+                        for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
+                                if ( formal == formals.end() ) {
+                                        if ( function->get_isVarArgs() ) {
+                                                convCost += Cost( 1, 0, 0 );
+                                                break;
+                                        } else {
+                                                return Cost::infinity;
+                                        }
-                                        formalTypes.clear();
-                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
-                                        formalType = formalTypes.begin();
-                                        ++formal;
+                                }
                                 PRINT(
                                         std::cerr << std::endl << "converting ";
                                         (*actualType)->print( std::cerr, 8 );
+                                        (*actual)->print( std::cerr, 8 );
                                         std::cerr << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cerr, 8 );
+                                )
                                 Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
+                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
                                         std::cerr << std::endl << "cost is" << newCost << std::endl;
 …
                                 actualCost += newCost;
                                 convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
                                 formalType++;
+                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
+                                formal++;
+                        }
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
 …
         /// Adds type variables to the open variable set and marks their assertions
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
 …
+        }
+        /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
+        /// producing expression(s) in out and their total cost in cost.
+        template< typename AltIterator, typename OutputIterator >
+        bool instantiateArgument( Type * formalType, Initializer * defaultValue, AltIterator & actualIt, AltIterator actualEnd, OpenVarSet & openVars, TypeEnvironment & resultEnv, AssertionSet & resultNeed, AssertionSet & resultHave, const SymTab::Indexer & indexer, Cost & cost, OutputIterator out ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
+                        // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
+                        TupleExpr * tupleExpr = new TupleExpr();
+                        for ( Type * type : *tupleType ) {
+                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
+                                        delete tupleExpr;
+                                        return false;
+                                }
+                        }
+                        tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
+                        *out++ = tupleExpr;
+                } else if ( actualIt != actualEnd ) {
+                        // both actualType and formalType are atomic (non-tuple) types - if they unify
+                        // then accept actual as an argument, otherwise return false (fail to instantiate argument)
+                        Expression * actual = actualIt->expr;
+                        Type * actualType = actual->get_result();
+                        PRINT(
+                                std::cerr << "formal type is ";
+                                formalType->print( std::cerr );
+                                std::cerr << std::endl << "actual type is ";
+                                actualType->print( std::cerr );
+                                std::cerr << std::endl;
+                        )
+                        if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                return false;
+                        }
+                        // move the expression from the alternative to the output iterator
+                        *out++ = actual;
+                        actualIt->expr = nullptr;
+                        cost += actualIt->cost;
+                        ++actualIt;
+                } else {
+                        // End of actuals - Handle default values
+                        if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
+                                // so far, only constant expressions are accepted as default values
+                                if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) ) {
+                                        if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
+                                                if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                                        // xxx - Don't know if this is right
+                                                        *out++ = cnstexpr->clone();
+                                                        return true;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return false;
+                } // if
+                return true;
+        }
+        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out ) {
+        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
                 simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
                 // make sure we don't widen any existing bindings
 …
                 resultEnv.extractOpenVars( openVars );
+                // flatten actuals so that each actual has an atomic (non-tuple) type
+                AltList exploded;
+                Tuples::explode( actuals, indexer, back_inserter( exploded ) );
+                AltList::iterator actualExpr = exploded.begin();
+                AltList::iterator actualEnd = exploded.end();
+                for ( DeclarationWithType * formal : formals ) {
+                        // match flattened actuals with formal parameters - actuals will be grouped to match
+                        // with formals as appropriate
+                        Cost cost;
+                        std::list< Expression * > newExprs;
+                        ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
+                        if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
+                                deleteAll( newExprs );
+                                return false;
+                        }
+                        // success - produce argument as a new alternative
+                        assert( newExprs.size() == 1 );
+                        out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
+                }
+                if ( actualExpr != actualEnd ) {
+                        // there are still actuals remaining, but we've run out of formal parameters to match against
+                        // this is okay only if the function is variadic
+                        if ( ! isVarArgs ) {
+                                return false;
+                        }
+                        out.splice( out.end(), exploded, actualExpr, actualEnd );
+                /*
+                  Tuples::NameMatcher matcher( formals );
+                  try {
+                  matcher.match( actuals );
+                  } catch ( Tuples::NoMatch &e ) {
+                  std::cerr << "Alternative doesn't match: " << e.message << std::endl;
+                  }
+                */
+                std::list< DeclarationWithType* >::iterator formal = formals.begin();
+                for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
+                        for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
+                                if ( formal == formals.end() ) {
+                                        return isVarArgs;
+                                }
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        (*formal)->get_type()->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        (*actual)->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                        return false;
+                                }
+                                formal++;
+                        }
+                }
+                // Handling of default values
+                while ( formal != formals.end() ) {
+                        if ( ObjectDecl *od = dynamic_cast<ObjectDecl *>( *formal ) )
+                                if ( SingleInit *si = dynamic_cast<SingleInit *>( od->get_init() ))
+                                        // so far, only constant expressions are accepted as default values
+                                        if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) )
+                                                if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) )
+                                                        if ( unify( (*formal)->get_type(), cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                                                // XXX Don't know if this is right
+                                                                actuals.push_back( Alternative( cnstexpr->clone(), env, Cost::zero ) );
+                                                                formal++;
+                                                                if ( formal == formals.end()) break;
+                                                        }
+                        return false;
+                }
                 return true;
 …
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
                                 Expression *varExpr = new VariableExpr( candDecl );
+                                delete varExpr->get_result();
+                                varExpr->set_result( adjType->clone() );
+                                deleteAll( varExpr->get_results() );
+                                varExpr->get_results().clear();
+                                varExpr->get_results().push_front( adjType->clone() );
                                 PRINT(
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
 …
         template< typename OutputIterator >
         void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out ) {
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
                 OpenVarSet openVars;
                 AssertionSet resultNeed, resultHave;
                 TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
+                AltList instantiatedActuals; // filled by instantiate function
+                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
+                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave ) ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
                         Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
                         makeExprList( instantiatedActuals, appExpr->get_args() );
+                        Alternative newAlt( appExpr, resultEnv, sumCost( actualAlt ) );
+                        makeExprList( actualAlt, appExpr->get_args() );
                         PRINT(
                                 std::cerr << "need assertions:" << std::endl;
 …
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 UntypedExpr *vexpr = untypedExpr->clone();
                                 vexpr->set_result( pt.clone() );
+                                vexpr->get_results().push_front( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
                                 return;
 …
                 combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+                // take care of possible tuple assignments
+                // if not tuple assignment, assignment is taken care of as a normal function call
+                Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
+                Tuples::TupleAssignSpotter tassign( this );
+                if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
+                        // take care of possible tuple assignments, or discard expression
+                        return;
+                } // else ...
                 AltList candidates;
 …
                                 // check if the type is pointer to function
                                 PointerType *pointer;
                                 if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
 …
                                                 // check if the type is pointer to function
                                                 PointerType *pointer;
+                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( funcOp->expr->get_results().size() == 1
+                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
 …
                         PRINT(
+                                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                assert( appExpr );
+                                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                                assert( pointer );
+                                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                assert( function );
                                 std::cerr << "Case +++++++++++++" << std::endl;
                                 std::cerr << "formals are:" << std::endl;
 …
         bool isLvalue( Expression *expr ) {
+                // xxx - recurse into tuples?
+                return expr->has_result() && expr->get_result()->get_isLvalue();
+                for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                        if ( !(*i)->get_isLvalue() ) return false;
+                } // for
+                return true;
+        }
 …
         void AlternativeFinder::visit( CastExpr *castExpr ) {
+                Type *& toType = castExpr->get_result();
+                toType = resolveTypeof( toType, indexer );
+                SymTab::validateType( toType, &indexer );
+                adjustExprType( toType, env, indexer );
+                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
+                        *i = resolveTypeof( *i, indexer );
+                        SymTab::validateType( *i, &indexer );
+                        adjustExprType( *i, env, indexer );
+                } // for
                 AlternativeFinder finder( indexer, env );
 …
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
                         if ( discardedValues < 0 ) continue;
+                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
+                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
+                        std::advance( candidate_end, castExpr->get_results().size() );
                         // unification run for side-effects
+                        unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
+                                           (*i).expr->get_results().begin(), candidate_end,
+                                   i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
+                                                                                  castExpr->get_results().begin(), castExpr->get_results().end(),
+                                                                                  indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
 …
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
                                 addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
                                 addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
                                 addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        if ( agg->expr->get_results().size() == 1 ) {
+                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } // if
                         } // if
                 } // for
 …
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
+                                NameExpr nameExpr( "" );
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
+                                NameExpr nameExpr( "" );
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } // if
                 } // for
 …
                         alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
                         for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
                                 alternatives.back().expr->set_result( (*i)->get_type()->clone() );
+                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
                         } // for
                 } // if
 …
                                                         finder.find( attrExpr->get_expr() );
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
                                                                 if ( choice->expr->get_result()->size() == 1 ) {
                                                                         resolveAttr(*i, function, choice->expr->get_result(), choice->env );
+                                                                if ( choice->expr->get_results().size() == 1 ) {
+                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
                                                                 } // fi
                                                         } // for
 …
                                         AssertionSet needAssertions, haveAssertions;
                                         Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
                                         Type* commonType = nullptr;
                                         if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                        std::list< Type* > commonTypes;
+                                        if ( unifyList( second->expr->get_results().begin(), second->expr->get_results().end(), third->expr->get_results().begin(), third->expr->get_results().end(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
                                                 ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
+                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
+                                                std::list< Type* >::const_iterator original = second->expr->get_results().begin();
+                                                std::list< Type* >::const_iterator commonType = commonTypes.begin();
+                                                for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
+                                                        if ( *commonType ) {
+                                                                newExpr->get_results().push_back( *commonType );
+                                                        } else {
+                                                                newExpr->get_results().push_back( (*original)->clone() );
+                                                        } // if
+                                                } // for
                                                 newAlt.expr = newExpr;
                                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
 …
                         TupleExpr *newExpr = new TupleExpr;
                         makeExprList( *i, newExpr->get_exprs() );
+                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
+                        for ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
+                                for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
+                                        newExpr->get_results().push_back( (*resultType)->clone() );
+                                } // for
+                        } // for
                         TypeEnvironment compositeEnv;
 …
+                }
+        }
-        void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
-                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+        }
-        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
-                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
+        }
-        void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
-                AlternativeFinder finder( indexer, env );
-                finder.findWithAdjustment( unqExpr->get_expr() );
-                for ( Alternative & alt : finder.alternatives ) {
-                        // ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
-                        UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
-                        alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/AlternativeFinder.h

-              r1f44196
+              r3a2128f
                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
                 virtual void visit( ConstructorExpr * ctorExpr );
+                virtual void visit( TupleIndexExpr *tupleExpr );
+                virtual void visit( TupleAssignExpr *tupleExpr );
+                virtual void visit( UniqueExpr *unqExpr );
+                /// Runs a new alternative finder on each element in [begin, end)
+                /// and writes each alternative finder to out.
+          public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
                 template< typename InputIterator, typename OutputIterator >
                 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
+          private:
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                /// Adds alternatives for member expressions where the left side has tuple type
+                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name );
                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
                 bool instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out );
+                bool instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave );
                 template< typename OutputIterator >
                 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out );
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out );
                 template< typename OutputIterator >
                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
 …
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
-        template< typename InputIterator, typename OutputIterator >
-        void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
-                AltList alternatives;
-                // select the alternatives that have the minimum parameter cost
-                Cost minCost = Cost::infinity;
-                for ( InputIterator i = begin; i != end; ++i ) {
-                        if ( i->cost < minCost ) {
-                                minCost = i->cost;
-                                i->cost = i->cvtCost;
-                                alternatives.clear();
-                                alternatives.push_back( *i );
-                        } else if ( i->cost == minCost ) {
-                                i->cost = i->cvtCost;
-                                alternatives.push_back( *i );
+                        }
+                }
-                std::copy( alternatives.begin(), alternatives.end(), out );
+        }
-        Cost sumCost( const AltList &in );
-        template< typename InputIterator >
-        void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
-                while ( begin != end ) {
-                        result.simpleCombine( (*begin++).env );
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/AlternativePrinter.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // AlternativePrinter.cc --
+// AlternativePrinter.cc --
 //
 // Author           : Richard C. Bilson
 …
                 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
                         os << "Alternative " << count++ << " ==============" << std::endl;
                         i->expr->get_result()->print( os );
+                        printAll( i->expr->get_results(), os );
                         //    i->print( os );
                         os << std::endl;

src/ResolvExpr/ConversionCost.cc

r1f44196	r3a2128f
240	240	std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
241	241	std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
242		while ( srcIt != tupleType->get_types().end() ~~&& destIt != destAsTuple->get_types().end()~~ ) {
	242	while ( srcIt != tupleType->get_types().end() ) {
243	243	Cost newCost = conversionCost( srcIt++, destIt++, indexer, env );
244	244	if ( newCost == Cost::infinity ) {

src/ResolvExpr/FindOpenVars.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // FindOpenVars.cc --
+// FindOpenVars.cc --
 //
 // Author           : Richard C. Bilson
 …
         void FindOpenVars::common_action( Type *type ) {
                 if ( nextIsOpen ) {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 openVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
 …
+                        }
                 } else {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 closedVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {

src/ResolvExpr/RenameVars.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // RenameVars.cc --
+// RenameVars.cc --
 //
 // Author           : Richard C. Bilson
 …
                         mapStack.push_front( mapStack.front() );
                         // renames all "forall" type names to `_${level}_${name}'
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 std::ostringstream output;
                                 output << "_" << level << "_" << (*i)->get_name();

src/ResolvExpr/ResolveTypeof.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // ResolveTypeof.cc --
+// ResolveTypeof.cc --
 //
 // Author           : Richard C. Bilson
 …
                 if ( typeofType->get_expr() ) {
                         Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
+                        assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
+                        Type *newType = newExpr->get_result();
+                        assert( newExpr->get_results().size() > 0 );
+                        Type *newType;
+                        if ( newExpr->get_results().size() > 1 ) {
+                                TupleType *tupleType = new TupleType( Type::Qualifiers() );
+                                cloneAll( newExpr->get_results(), tupleType->get_types() );
+                                newType = tupleType;
+                        } else {
+                                newType = newExpr->get_results().front()->clone();
+                        } // if
                         delete typeofType;
                         return newType;

src/ResolvExpr/Resolver.cc

-              r1f44196
+              r3a2128f
 #include "RenameVars.h"
 #include "ResolveTypeof.h"
-#include "typeops.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
 …
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
           void fallbackInit( ConstructorInit * ctorInit );
+                Type * functionReturn = nullptr;
+                Type *initContext = nullptr;
+                std::list< Type * > functionReturn;
+                Type *initContext;
                 bool inEnumDecl = false;
         };
 …
                         const TypeEnvironment *newEnv = 0;
                         for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
                                 if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
+                                if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) {
                                         if ( newExpr ) {
                                                 throw SemanticError( "Too many interpretations for case control expression", untyped );
 …
                 Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
                 functionDecl->set_type( new_type );
+                ValueGuard< Type * > oldFunctionReturn( functionReturn );
+                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                std::list< Type * > oldFunctionReturn = functionReturn;
+                functionReturn.clear();
+                for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) {
+                        functionReturn.push_back( (*i)->get_type() );
+                } // for
                 SymTab::Indexer::visit( functionDecl );
+                functionReturn = oldFunctionReturn;
+        }
 …
         void Resolver::visit( ReturnStmt *returnStmt ) {
                 if ( returnStmt->get_expr() ) {
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
+                        cloneAll( functionReturn, castExpr->get_results() );
                         Expression *newExpr = findSingleExpression( castExpr, *this );
                         delete castExpr;
 …
                                 if ( isCharType( at->get_base() ) ) {
                                         // check if the resolved type is char *
                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
                                                 if ( isCharType( pt->get_base() ) ) {
                                                         // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
 …
                                 (*iter)->accept( *this );
                         } // for
-                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
-                        for ( Type * t : *tt ) {
-                                if ( iter == end ) break;
-                                initContext = t;
-                                (*iter++)->accept( *this );
+                        }
                 } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseStruct(), iter, end );

src/ResolvExpr/TypeEnvironment.cc

-              r1f44196
+              r3a2128f
+        }
         void TypeEnvironment::add( const Type::ForallList &tyDecls ) {
                 for ( Type::ForallList::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
+        void TypeEnvironment::add( const std::list< TypeDecl* > &tyDecls ) {
+                for ( std::list< TypeDecl* >::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
                         EqvClass newClass;
                         newClass.vars.insert( (*i)->get_name() );

src/ResolvExpr/TypeEnvironment.h

r1f44196	r3a2128f
55	55	bool lookup( const std::string &var, EqvClass &eqvClass ) const;
56	56	void add( const EqvClass &eqvClass );
57		void add( const ~~Type::ForallList~~ &tyDecls );
	57	void add( const std::list< TypeDecl* > &tyDecls );
58	58	template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
59	59	template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;

src/ResolvExpr/Unify.cc

-              r1f44196
+              r3a2128f
+        }
-        // xxx - compute once and store in the FunctionType?
-        Type * extractResultType( FunctionType * function ) {
-                if ( function->get_returnVals().size() == 0 ) {
-                        return new VoidType( Type::Qualifiers() );
-                } else if ( function->get_returnVals().size() == 1 ) {
-                        return function->get_returnVals().front()->get_type()->clone();
-                } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
-                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
-                        } // for
-                        return tupleType;
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/typeops.h

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // typeops.h --
+// typeops.h --
 //
 // Author           : Richard C. Bilson
 …
                 typedef typename InputIterator::value_type SetType;
                 typedef typename std::list< typename SetType::value_type > ListType;
                 if ( begin == end )     {
                         *out++ = ListType();
                         return;
                 } // if
                 InputIterator current = begin;
                 begin++;
 …
                 std::list< ListType > recursiveResult;
                 combos( begin, end, back_inserter( recursiveResult ) );
                 for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
                         for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
 …
                 } // for
+        }
         // in AdjustExprType.cc
         /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
 …
+        }
-        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
-        Type * extractResultType( FunctionType * functionType );
         // in CommonType.cc
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
 …
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
-        // flatten tuple type into list of types
-        template< typename OutputIterator >
-        void flatten( Type * type, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : tupleType->get_types() ) {
-                                flatten( t, out );
+                        }
-                } else {
-                        *out++ = type;
+                }
+        }
 } // namespace ResolvExpr

src/SymTab/Autogen.cc

-              r1f44196
+              r3a2128f
                 // This happens before function pointer type conversion, so need to do it manually here
                 VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
                 Type * assignVarExprType = assignVarExpr->get_result();
+                Type *& assignVarExprType = assignVarExpr->get_results().front();
                 assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
-                assignVarExpr->set_result( assignVarExprType );
                 ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
                 assignExpr->get_args().push_back( new VariableExpr( dstParam ) );

src/SymTab/Indexer.cc

-              r1f44196
+              r3a2128f
 namespace SymTab {
         template< typename TreeType, typename VisitorType >
         inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
+        template< typename Container, typename VisitorType >
+        inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
                 visitor.enterScope();
                 maybeAccept( tree, visitor );
+                acceptAll( container, visitor );
                 visitor.leaveScope();
+        }
 …
                 for ( DeclarationWithType * decl : copy ) {
                         if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
                                 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
+                                std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
                                 assert( ! params.empty() );
                                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
 …
         void Indexer::visit( ApplicationExpr *applicationExpr ) {
                 acceptNewScope( applicationExpr->get_result(), *this );
+                acceptAllNewScope( applicationExpr->get_results(), *this );
                 maybeAccept( applicationExpr->get_function(), *this );
                 acceptAll( applicationExpr->get_args(), *this );
 …
         void Indexer::visit( UntypedExpr *untypedExpr ) {
                 acceptNewScope( untypedExpr->get_result(), *this );
+                acceptAllNewScope( untypedExpr->get_results(), *this );
                 acceptAll( untypedExpr->get_args(), *this );
+        }
         void Indexer::visit( NameExpr *nameExpr ) {
                 acceptNewScope( nameExpr->get_result(), *this );
+                acceptAllNewScope( nameExpr->get_results(), *this );
+        }
         void Indexer::visit( AddressExpr *addressExpr ) {
                 acceptNewScope( addressExpr->get_result(), *this );
+                acceptAllNewScope( addressExpr->get_results(), *this );
                 maybeAccept( addressExpr->get_arg(), *this );
+        }
         void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
                 acceptNewScope( labAddressExpr->get_result(), *this );
+                acceptAllNewScope( labAddressExpr->get_results(), *this );
                 maybeAccept( labAddressExpr->get_arg(), *this );
+        }
         void Indexer::visit( CastExpr *castExpr ) {
                 acceptNewScope( castExpr->get_result(), *this );
+                acceptAllNewScope( castExpr->get_results(), *this );
                 maybeAccept( castExpr->get_arg(), *this );
+        }
         void Indexer::visit( UntypedMemberExpr *memberExpr ) {
                 acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
+        }
         void Indexer::visit( MemberExpr *memberExpr ) {
                 acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
+        }
         void Indexer::visit( VariableExpr *variableExpr ) {
                 acceptNewScope( variableExpr->get_result(), *this );
+                acceptAllNewScope( variableExpr->get_results(), *this );
+        }
         void Indexer::visit( ConstantExpr *constantExpr ) {
                 acceptNewScope( constantExpr->get_result(), *this );
+                acceptAllNewScope( constantExpr->get_results(), *this );
                 maybeAccept( constantExpr->get_constant(), *this );
+        }
         void Indexer::visit( SizeofExpr *sizeofExpr ) {
                 acceptNewScope( sizeofExpr->get_result(), *this );
+                acceptAllNewScope( sizeofExpr->get_results(), *this );
                 if ( sizeofExpr->get_isType() ) {
                         maybeAccept( sizeofExpr->get_type(), *this );
 …
         void Indexer::visit( AlignofExpr *alignofExpr ) {
                 acceptNewScope( alignofExpr->get_result(), *this );
+                acceptAllNewScope( alignofExpr->get_results(), *this );
                 if ( alignofExpr->get_isType() ) {
                         maybeAccept( alignofExpr->get_type(), *this );
 …
         void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
+        }
         void Indexer::visit( OffsetofExpr *offsetofExpr ) {
                 acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
 …
         void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
                 acceptNewScope( offsetPackExpr->get_result(), *this );
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
                 maybeAccept( offsetPackExpr->get_type(), *this );
+        }
         void Indexer::visit( AttrExpr *attrExpr ) {
                 acceptNewScope( attrExpr->get_result(), *this );
+                acceptAllNewScope( attrExpr->get_results(), *this );
                 if ( attrExpr->get_isType() ) {
                         maybeAccept( attrExpr->get_type(), *this );
 …
         void Indexer::visit( LogicalExpr *logicalExpr ) {
                 acceptNewScope( logicalExpr->get_result(), *this );
+                acceptAllNewScope( logicalExpr->get_results(), *this );
                 maybeAccept( logicalExpr->get_arg1(), *this );
                 maybeAccept( logicalExpr->get_arg2(), *this );
 …
         void Indexer::visit( ConditionalExpr *conditionalExpr ) {
                 acceptNewScope( conditionalExpr->get_result(), *this );
+                acceptAllNewScope( conditionalExpr->get_results(), *this );
                 maybeAccept( conditionalExpr->get_arg1(), *this );
                 maybeAccept( conditionalExpr->get_arg2(), *this );
 …
         void Indexer::visit( CommaExpr *commaExpr ) {
                 acceptNewScope( commaExpr->get_result(), *this );
+                acceptAllNewScope( commaExpr->get_results(), *this );
                 maybeAccept( commaExpr->get_arg1(), *this );
                 maybeAccept( commaExpr->get_arg2(), *this );
 …
         void Indexer::visit( TupleExpr *tupleExpr ) {
                 acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAllNewScope( tupleExpr->get_results(), *this );
                 acceptAll( tupleExpr->get_exprs(), *this );
+        }
+        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                enterScope();
+                acceptAll( tupleExpr->get_tempDecls(), *this );
+                acceptAll( tupleExpr->get_assigns(), *this );
+                leaveScope();
+        void Indexer::visit( SolvedTupleExpr *tupleExpr ) {
+                acceptAllNewScope( tupleExpr->get_results(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
+        }
         void Indexer::visit( TypeExpr *typeExpr ) {
                 acceptNewScope( typeExpr->get_result(), *this );
+                acceptAllNewScope( typeExpr->get_results(), *this );
                 maybeAccept( typeExpr->get_type(), *this );
+        }
 …
         void Indexer::visit( UntypedValofExpr *valofExpr ) {
                 acceptNewScope( valofExpr->get_result(), *this );
+                acceptAllNewScope( valofExpr->get_results(), *this );
                 maybeAccept( valofExpr->get_body(), *this );
+        }

src/SymTab/Indexer.h

-              r1f44196
+              r3a2128f
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( SolvedTupleExpr *tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr *asmExpr );
                 virtual void visit( UntypedValofExpr *valofExpr );
-                virtual void visit( TupleExpr *tupleExpr );
-                virtual void visit( TupleAssignExpr *tupleExpr );
                 virtual void visit( TraitInstType *contextInst );

src/SymTab/Mangler.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // Mangler.cc --
+// Mangler.cc --
 //
 // Author           : Richard C. Bilson
 …
                 return mangler.get_mangleName();
+        }
         Mangler::Mangler( bool mangleOverridable, bool typeMode )
                 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
                 varNums = rhs.varNums;
 …
                         "Ir",   // LongDoubleImaginary
                 };
                 printQualifiers( basicType );
                 mangleName << btLetter[ basicType->get_kind() ];
 …
                 // skip if not including qualifiers
                 if ( typeMode ) return;
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
                         int tcount = 0, dcount = 0, fcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
                                   case TypeDecl::Any:

src/SymTab/Validate.cc

-              r1f44196
+              r3a2128f
 // - All enumeration constants have type EnumInstType.
 //
 // - The type "void" never occurs in lists of function parameter or return types.  A function
 //   taking no arguments has no argument types.
+// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
+//   taking no arguments has no argument types, and tuples are flattened.
 //
 // - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
 …
                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
+        }
+        // xxx - shouldn't this be declsToAddBefore?
         template< typename AggDecl >
         void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
 …
         /// Fix up assertions
         void forallFixer( Type *func ) {
                 for ( Type::ForallList::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
+                for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
                         std::list< DeclarationWithType * > toBeDone, nextRound;
                         toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );

src/SynTree/AddressExpr.cc

-              r1f44196
+              r3a2128f
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
                 set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
+        }
+        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
+                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
+        } // for
+}
 …
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
                 arg->print( os, indent+2 );
+    arg->print( os, indent+2 );
         } // if
+}

src/SynTree/ApplicationExpr.cc

-              r1f44196
+              r3a2128f
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
+#include "ResolvExpr/typeops.h"
 ParamEntry::ParamEntry( const ParamEntry &other ) :
 …
 ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
+        PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
+        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
+        assert( pointer );
+        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+        assert( function );
         set_result( ResolvExpr::extractResultType( function ) );
         assert( has_result() );
+        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                get_results().push_back( (*i)->get_type()->clone() );
+        } // for
+}

src/SynTree/CommaExpr.cc

-              r1f44196
+              r3a2128f
         // to false on all result types. Actually doing this causes some strange things
         // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
+        set_result( maybeClone( arg2->get_result() ) );
+        // get_type->set_isLvalue( false );
+        cloneAll( arg2->get_results(), get_results() );
+        // for ( Type *& type : get_results() ) {
+        //      type->set_isLvalue( false );
+        // }
+}

src/SynTree/CompoundStmt.cc

-              r1f44196
+              r3a2128f
 #include "Expression.h"
 #include "Declaration.h"
-#include "SynTree/VarExprReplacer.h"
 using std::string;
 using std::endl;
+class VarExprReplacer : public Visitor {
+public:
+  typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+private:
+  const DeclMap & declMap;
+public:
+  VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+  // replace variable with new node from decl map
+  virtual void visit( VariableExpr * varExpr ) {
+    if ( declMap.count( varExpr->get_var() ) ) {
+      varExpr->set_var( declMap.at( varExpr->get_var() ) );
+    }
+  }
+};
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
 …
         cloneAll( other.kids, kids );
+        // when cloning a compound statement, we may end up cloning declarations which
+        // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
+        // does a shallow copy, so the VariableExpr will end up pointing to the original
+        // declaration. If the original declaration is deleted, e.g. because the original
+        // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
+        // find all DeclarationWithType nodes (since a VariableExpr must point to a
+        // DeclarationWithType) in the original CompoundStmt and map them to the cloned
+        // node in the new CompoundStmt ('this'), then replace the Declarations referred to
+        // by each VariableExpr according to the constructed map. Note that only the declarations
+        // in the current level are collected into the map, because child CompoundStmts will
+        // recursively execute this routine. There may be more efficient ways of doing
+        // this.
+        VarExprReplacer::DeclMap declMap;
+        std::list< Statement * >::const_iterator origit = other.kids.begin();
+        for ( Statement * s : kids ) {
+                assert( origit != other.kids.end() );
+                Statement * origStmt = *origit++;
+                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
+                        DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( origStmt );
+                        assert( origDeclStmt );
+                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
+                                DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+                                assert( origdwt );
+                                assert( dwt->get_name() == origdwt->get_name() );
+                                declMap[ origdwt ] = dwt;
+                        }
+                }
+        }
+        if ( ! declMap.empty() ) {
+                VarExprReplacer replacer( declMap );
+                accept( replacer );
+        }
+  // when cloning a compound statement, we may end up cloning declarations which
+  // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
+  // does a shallow copy, so the VariableExpr will end up pointing to the original
+  // declaration. If the original declaration is deleted, e.g. because the original
+  // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
+  // find all DeclarationWithType nodes (since a VariableExpr must point to a
+  // DeclarationWithType) in the original CompoundStmt and map them to the cloned
+  // node in the new CompoundStmt ('this'), then replace the Declarations referred to
+  // by each VariableExpr according to the constructed map. Note that only the declarations
+  // in the current level are collected into the map, because child CompoundStmts will
+  // recursively execute this routine. There may be more efficient ways of doing
+  // this.
+  VarExprReplacer::DeclMap declMap;
+  std::list< Statement * >::const_iterator origit = other.kids.begin();
+  for ( Statement * s : kids ) {
+    assert( origit != other.kids.end() );
+    if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
+      DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( *origit );
+      assert( origDeclStmt );
+      if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
+        DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+        assert( origdwt );
+        declMap[ origdwt ] = dwt;
+      }
+    }
+  }
+  if ( ! declMap.empty() ) {
+    VarExprReplacer replacer( declMap );
+    accept( replacer );
+  }
+}

src/SynTree/Expression.cc

-              r1f44196
+              r3a2128f
+Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
+Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
+Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+        cloneAll( other.results, results );
+}
 …
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
+        delete result;
+        deleteAll( results );
+}
+void Expression::add_result( Type *t ) {
+        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
+                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
+        } else {
+                results.push_back(t);
+        } // if
+}
 …
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
         set_result( constant.get_type()->clone() );
+        add_result( constant.get_type()->clone() );
+}
 …
         assert( var );
         assert( var->get_type() );
+        Type * type = var->get_type()->clone();
+        type->set_isLvalue( true );
+        set_result( type );
+        add_result( var->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
+}
 …
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
 …
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
         set_result(toType);
+        add_result(toType);
+}
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result( new VoidType( Type::Qualifiers() ) );
+}
 …
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        if ( result->isVoid() ) {
+                os << "nothing";
+        if ( results.empty() ) {
+                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
         } else {
                 result->print( os, indent+2 );
+                printAll(results, os, indent+2);
         } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
+}
 UntypedMemberExpr::~UntypedMemberExpr() {
         delete aggregate;
-        delete member;
+}
 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, ' ' );
+        os << "Untyped Member Expression, with field: " << get_member();
         Expression *agg = get_aggregate();
         os << "from aggregate: " << std::endl;
+        os << ", from aggregate: ";
         if (agg != 0) {
                 os << std::string( indent + 4, ' ' );
                 agg->print(os, indent + 4);
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
+        }
         os << std::string( indent+2, ' ' );
 …
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
+        set_result( member->get_type()->clone() );
+        get_result()->set_isLvalue( true );
+        add_result( member->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
+}
 …
+}
+UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
                 Expression( _aname ), function(_function), args(_args) {}
+UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
 …
+}
+UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
 UntypedExpr::~UntypedExpr() {
         delete function;
         deleteAll( args );
+}
-UntypedExpr * UntypedExpr::createDeref( Expression * expr ) {
-        UntypedExpr * ret = new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ expr } );
-        if ( Type * type = expr->get_result() ) {
-                Type * base = InitTweak::getPointerBase( type );
-                if ( ! base ) {
-                        std::cerr << type << std::endl;
+                }
-                assertf( base, "expected pointer type in dereference\n" );
-                ret->set_result( maybeClone( base ) );
+        }
-        return ret;
+}
-UntypedExpr * UntypedExpr::createAssign( Expression * arg1, Expression * arg2 ) {
-        assert( arg1 && arg2 );
-        UntypedExpr * ret = new UntypedExpr( new NameExpr( "?=?" ), std::list< Expression * >{ arg1, arg2 } );
-        if ( arg1->get_result() && arg2->get_result() ) {
-                // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
-                // so the result is the type of the RHS
-                ret->set_result( arg2->get_result()->clone() );
+        }
-        return ret;
+}
 void UntypedExpr::print( std::ostream &os, int indent ) const {
 …
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
 …
 void ConditionalExpr::print( std::ostream &os, int indent ) const {
+        os << "Conditional expression on: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        os << std::string( indent, ' ' ) << "Conditional expression on: " << std::endl;
         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;
 …
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
+        assert( callExpr->has_result() );
+        set_result( callExpr->get_result()->clone() );
+        cloneAll( callExpr->get_results(), results );
+}
 …
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
         set_result( maybeClone( arg->get_result() ) );
+        cloneAll( arg->get_results(), results );
+}
 …
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        assert( type && initializer );
+        set_result( type->clone() );
+}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
+        add_result( type->clone() );
+}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
 CompoundLiteralExpr::~CompoundLiteralExpr() {
 …
 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
         os << "Compound Literal Expression: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        type->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        initializer->print( os, indent + 2 );
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
+}
 …
 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() ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
         os << "Range Expression: ";
+        os << std::string( indent, ' ' ) << "Range Expression: ";
         low->print( os, indent );
         os << " ... ";
         high->print( os, indent );
+}
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
-        assert( statements );
-        std::list< Statement * > & body = statements->get_kids();
-        if ( ! body.empty() ) {
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
+                }
+        }
+}
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
-StmtExpr::~StmtExpr() {
-        delete statements;
+}
-void StmtExpr::print( std::ostream &os, int indent ) const {
-        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
-        statements->print( os, indent+2 );
+}
-long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
-        assert( expr );
-        assert( count != -1 );
-        if ( id == -1 ) id = count++;
-        if ( expr->get_result() ) {
-                set_result( expr->get_result()->clone() );
+        }
+}
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+}
-UniqueExpr::~UniqueExpr() {
-        delete expr;
-        delete object;
-        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 << " with decl: ";
-                get_object()->printShort( os, indent+2 );
+        }
+}

src/SynTree/Expression.h

-              r1f44196
+              r3a2128f
         virtual ~Expression();
+        Type *& get_result() { return result; }
+        void set_result( Type *newValue ) { result = newValue; }
+        bool has_result() const { return result != nullptr; }
+        std::list<Type *>& get_results() { return results; }
+        void add_result( Type *t );
         TypeSubstitution *get_env() const { return env; }
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
         Type * result;
+        std::list<Type *> results;
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name
 …
 class UntypedExpr : public Expression {
   public:
         UntypedExpr( Expression *function, const std::list<Expression *> &args = std::list< Expression * >(), Expression *_aname = nullptr );
+        UntypedExpr( Expression *function, Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr &other );
+        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = nullptr );
         virtual ~UntypedExpr();
 …
         std::list<Expression*>& get_args() { return args; }
-        static UntypedExpr * createDeref( Expression * arg );
-        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
         virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
 …
 class UntypedMemberExpr : public Expression {
   public:
         UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr &other );
         virtual ~UntypedMemberExpr();
         Expression * get_member() const { return member; }
         void set_member( Expression * newValue ) { member = newValue; }
+        std::string get_member() const { return member; }
+        void set_member( const std::string &newValue ) { member = newValue; }
         Expression *get_aggregate() const { return aggregate; }
         void set_aggregate( Expression *newValue ) { aggregate = newValue; }
 …
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
         Expression *member;
+        std::string member;
         Expression *aggregate;
 };
 …
 };
+/// TupleExpr represents a tuple expression ( [a, b, c] )
+class TupleExpr : public Expression {
+  public:
+        TupleExpr( Expression *_aname = nullptr );
+        TupleExpr( const TupleExpr &other );
+        virtual ~TupleExpr();
+        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
+        std::list<Expression*>& get_exprs() { return exprs; }
+        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
+        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;
+  private:
+        std::list<Expression*> exprs;
+};
+/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+class SolvedTupleExpr : public Expression {
+  public:
+        SolvedTupleExpr( Expression *_aname = nullptr ) : Expression( _aname ) {}
+        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = nullptr );
+        SolvedTupleExpr( const SolvedTupleExpr &other );
+        virtual ~SolvedTupleExpr() {}
+        std::list<Expression*> &get_exprs() { return exprs; }
+        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
+        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;
+  private:
+        std::list<Expression*> exprs;
+};
 /// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
 …
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr &other );
         virtual ~CompoundLiteralExpr();
+        ~CompoundLiteralExpr();
         Type * get_type() const { return type; }
 …
   private:
         Expression *low, *high;
-};
-/// TupleExpr represents a tuple expression ( [a, b, c] )
-class TupleExpr : public Expression {
-  public:
-        TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
-        TupleExpr( const TupleExpr &other );
-        virtual ~TupleExpr();
-        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
-        std::list<Expression*>& get_exprs() { return exprs; }
-        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
-        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;
-  private:
-        std::list<Expression*> exprs;
-};
-/// TupleIndexExpr represents an element selection operation on a tuple value, e.g. t.3 after processing by the expression analyzer
-class TupleIndexExpr : public Expression {
-  public:
-        TupleIndexExpr( Expression * tuple, unsigned int index );
-        TupleIndexExpr( const TupleIndexExpr &other );
-        virtual ~TupleIndexExpr();
-        Expression * get_tuple() const { return tuple; }
-        int get_index() const { return index; }
-        TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
-        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
-        virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *this ); }
-        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;
-  private:
-        Expression * tuple;
-        unsigned int index;
-};
-/// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
-class MemberTupleExpr : public Expression {
-  public:
-        MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
-        MemberTupleExpr( const MemberTupleExpr &other );
-        virtual ~MemberTupleExpr();
-        Expression * get_member() const { return member; }
-        Expression * get_aggregate() const { return aggregate; }
-        MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
-        MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
-        virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *this ); }
-        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;
-  private:
-        Expression * member;
-        Expression * aggregate;
-};
-/// TupleAssignExpr represents a multiple assignment operation, where both sides of the assignment have tuple type, e.g. [a, b, c] = [d, e, f];, a mass assignment operation, where the left hand side has tuple type and the right hand side does not, e.g. [a, b, c] = 5.0;, or a tuple ctor/dtor expression
-class TupleAssignExpr : public Expression {
-  public:
-        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
-        TupleAssignExpr( const TupleAssignExpr &other );
-        virtual ~TupleAssignExpr();
-        std::list< Expression * > & get_assigns() { return assigns; }
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
-        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;
-  private:
-        std::list< Expression * > assigns; // assignment expressions that use tempDecls
-        std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
-};
-/// StmtExpr represents a GCC 'statement expression', e.g. ({ int x = 5; x; })
-class StmtExpr : public Expression {
-public:
-        StmtExpr( CompoundStmt *statements );
-        StmtExpr( const StmtExpr & other );
-        virtual ~StmtExpr();
-        CompoundStmt * get_statements() const { return statements; }
-        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
-        virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
-        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;
-private:
-        CompoundStmt * statements;
-};
-class UniqueExpr : public Expression {
-public:
-        UniqueExpr( Expression * expr, long long idVal = -1 );
-        UniqueExpr( const UniqueExpr & other );
-        ~UniqueExpr();
-        Expression * get_expr() const { return expr; }
-        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
-        ObjectDecl * get_object() const { return object; }
-        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
-        VariableExpr * get_var() const { return var; }
-        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
-        int get_id() const { return id; }
-        virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
-        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;
-private:
-        Expression * expr;
-        ObjectDecl * object;
-        VariableExpr * var;
-        int id;
-        static long long count;
 };

src/SynTree/Initializer.h

r1f44196	r3a2128f
23	23
24	24	#include <cassert>
25
26		~~const std::list<Expression*> noDesignators;~~
27	25
28	26	// Initializer: base class for object initializers (provide default values)

src/SynTree/Mutator.cc

-              r1f44196
+              r3a2128f
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
         applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
+        mutateAll( applicationExpr->get_results(), *this );
         applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
         mutateAll( applicationExpr->get_args(), *this );
 …
 Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
         untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
+        mutateAll( untypedExpr->get_results(), *this );
         mutateAll( untypedExpr->get_args(), *this );
         return untypedExpr;
 …
 Expression *Mutator::mutate( NameExpr *nameExpr ) {
         nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
+        mutateAll( nameExpr->get_results(), *this );
         return nameExpr;
+}
 Expression *Mutator::mutate( AddressExpr *addressExpr ) {
         addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
+        mutateAll( addressExpr->get_results(), *this );
         addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
         return addressExpr;
 …
 Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
         labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
+        mutateAll( labelAddressExpr->get_results(), *this );
         labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
         return labelAddressExpr;
 …
 Expression *Mutator::mutate( CastExpr *castExpr ) {
         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
+        mutateAll( castExpr->get_results(), *this );
         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
         return castExpr;
 …
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
+        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
+        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+        memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
+        return memberExpr;
+}
+Expression *Mutator::mutate( MemberExpr *memberExpr ) {
+        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
+        mutateAll( memberExpr->get_results(), *this );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         return memberExpr;
+}
+Expression *Mutator::mutate( MemberExpr *memberExpr ) {
+        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+        return memberExpr;
+}
 Expression *Mutator::mutate( VariableExpr *variableExpr ) {
         variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
+        mutateAll( variableExpr->get_results(), *this );
         return variableExpr;
+}
 Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
         constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
+        mutateAll( constantExpr->get_results(), *this );
 //  maybeMutate( constantExpr->get_constant(), *this )
         return constantExpr;
 …
 Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
         sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
+        mutateAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
 …
 Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
         alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
+        mutateAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
 …
 Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         return offsetofExpr;
 …
 Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
 …
 Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
         offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
+        mutateAll( offsetPackExpr->get_results(), *this );
         offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
         return offsetPackExpr;
 …
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
+        mutateAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
 …
 Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
         logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
+        mutateAll( logicalExpr->get_results(), *this );
         logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
         logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
 …
 Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
         conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
+        mutateAll( conditionalExpr->get_results(), *this );
         conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
         conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
 …
 Expression *Mutator::mutate( CommaExpr *commaExpr ) {
         commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
+        mutateAll( commaExpr->get_results(), *this );
         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
 …
+}
+Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
+Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
 Expression *Mutator::mutate( TypeExpr *typeExpr ) {
         typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
+        mutateAll( typeExpr->get_results(), *this );
         typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
         return typeExpr;
 …
 Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
         ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
+        mutateAll( ctorExpr->get_results(), *this );
         ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
         return ctorExpr;
 …
 Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
         compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
+        mutateAll( compLitExpr->get_results(), *this );
         compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
 …
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
         valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
+        mutateAll( valofExpr->get_results(), *this );
         return valofExpr;
+}
 …
         rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
         return rangeExpr;
+}
-Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        mutateAll( tupleExpr->get_exprs(), *this );
-        return tupleExpr;
+}
-Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
-        return tupleExpr;
+}
-Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
-        tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
-        return tupleExpr;
+}
-Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
-        assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
-        mutateAll( assignExpr->get_tempDecls(), *this );
-        mutateAll( assignExpr->get_assigns(), *this );
-        return assignExpr;
+}
-Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
-        stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
-        stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
-        return stmtExpr;
+}
-Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
-        uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
-        uniqueExpr->set_expr( maybeMutate( uniqueExpr->get_expr(), *this ) );
-        return uniqueExpr;
+}

src/SynTree/Mutator.h

-              r1f44196
+              r3a2128f
         virtual Expression* mutate( ConditionalExpr *conditionalExpr );
         virtual Expression* mutate( CommaExpr *commaExpr );
+        virtual Expression* mutate( TupleExpr *tupleExpr );
+        virtual Expression* mutate( SolvedTupleExpr *tupleExpr );
         virtual Expression* mutate( TypeExpr *typeExpr );
         virtual Expression* mutate( AsmExpr *asmExpr );
 …
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
-        virtual Expression* mutate( TupleExpr *tupleExpr );
-        virtual Expression* mutate( TupleIndexExpr *tupleExpr );
-        virtual Expression* mutate( MemberTupleExpr *tupleExpr );
-        virtual Expression* mutate( TupleAssignExpr *assignExpr );
-        virtual Expression* mutate( StmtExpr * stmtExpr );
-        virtual Expression* mutate( UniqueExpr * uniqueExpr );
         virtual Type* mutate( VoidType *basicType );

src/SynTree/ReferenceToType.cc

r1f44196	r3a2128f
56	56	}
57	57	} // namespace
58
59		~~StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct ) : Parent( tq, baseStruct->get_name() ), baseStruct( baseStruct ) {}~~
60	58
61	59	std::string StructInstType::typeString() const { return "struct"; }

src/SynTree/SynTree.h

-              r1f44196
+              r3a2128f
 class ConditionalExpr;
 class CommaExpr;
+class TupleExpr;
+class SolvedTupleExpr;
 class TypeExpr;
 class AsmExpr;
 …
 class UntypedValofExpr;
 class RangeExpr;
-class TupleExpr;
-class TupleIndexExpr;
-class MemberTupleExpr;
-class TupleAssignExpr;
-class StmtExpr;
-class UniqueExpr;
 class Type;

src/SynTree/TupleExpr.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // TupleExpr.cc --
+// TupleExpr.cc --
 //
 // Author           : Richard C. Bilson
 …
 #include "Expression.h"
 #include "Common/utility.h"
-#include "Type.h"
-#include "Declaration.h"
-#include "Tuples/Tuples.h"
-#include "VarExprReplacer.h"
+TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+        if ( ! exprs.empty() ) {
+                if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
+                        set_result( Tuples::makeTupleType( exprs ) );
+                }
+        }
+TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
+}
 …
 void TupleExpr::print( std::ostream &os, int indent ) const {
         os << "Tuple:" << std::endl;
+        os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
         Expression::print( os, indent );
+}
+TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
+        TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
+        assert( type->size() > index );
+        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
+        get_result()->set_isLvalue( type->get_isLvalue() );
+SolvedTupleExpr::SolvedTupleExpr( std::list<Expression *> &_exprs, Expression *_aname ) : Expression( _aname ) {
+        std::copy(_exprs.begin(), _exprs.end(), back_inserter(exprs));
+}
+TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
+SolvedTupleExpr::SolvedTupleExpr( const SolvedTupleExpr &other ) : Expression( other ) {
+        cloneAll( other.exprs, exprs );
+}
+TupleIndexExpr::~TupleIndexExpr() {
+        delete tuple;
+}
+void TupleIndexExpr::print( std::ostream &os, int 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;
+void SolvedTupleExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Solved Tuple:" << std::endl;
+        printAll( exprs, os, indent+2 );
         Expression::print( os, indent );
+}
-MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
-        set_result( maybeClone( member->get_result() ) ); // xxx - ???
+}
-MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
+}
-MemberTupleExpr::~MemberTupleExpr() {
-        delete member;
-        delete aggregate;
+}
-void MemberTupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Member Tuple Expression, with aggregate:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        aggregate->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        member->print( os, indent+2 );
-        Expression::print( os, indent );
+}
-TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
-        set_result( Tuples::makeTupleType( assigns ) );
+}
-TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ) {
-        cloneAll( other.assigns, assigns );
-        cloneAll( other.tempDecls, tempDecls );
-        // clone needs to go into assigns and replace tempDecls
-        VarExprReplacer::DeclMap declMap;
-        std::list< ObjectDecl * >::const_iterator origit = other.tempDecls.begin();
-        for ( ObjectDecl * temp : tempDecls ) {
-                assert( origit != other.tempDecls.end() );
-                ObjectDecl * origTemp = *origit++;
-                assert( origTemp );
-                assert( temp->get_name() == origTemp->get_name() );
-                declMap[ origTemp ] = temp;
+        }
-        if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                for ( Expression * assn : assigns ) {
-                        assn->accept( replacer );
+                }
+        }
+}
-TupleAssignExpr::~TupleAssignExpr() {
-        deleteAll( assigns );
-        // deleteAll( tempDecls );
+}
-void TupleAssignExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Assignment Expression, with temporaries:" << std::endl;
-        printAll( tempDecls, os, indent+4 );
-        os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;
-        printAll( assigns, os, indent+4 );
-        Expression::print( os, indent );
+}
 // Local Variables: //

src/SynTree/TupleType.cc

-              r1f44196
+              r3a2128f
 // file "LICENCE" distributed with Cforall.
 //
 // TupleType.cc --
+// TupleType.cc --
 //
 // Author           : Richard C. Bilson
 …
 #include "Common/utility.h"
 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types ) : Type( tq ), types( types ) {
+TupleType::TupleType( const Type::Qualifiers &tq ) : Type( tq ) {
+}

src/SynTree/Type.h

-              r1f44196
+              r3a2128f
 #include "Visitor.h"
 #include "Mutator.h"
-#include "Common/utility.h"
 class Type {
 …
                 Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
-                Qualifiers &operator&=( const Qualifiers &other );
                 Qualifiers &operator+=( const Qualifiers &other );
                 Qualifiers &operator-=( const Qualifiers &other );
 …
         void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
         void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
+        typedef std::list<TypeDecl *> ForallList;
+        ForallList& get_forall() { return forall; }
+        /// How many elemental types are represented by this type
+        virtual unsigned size() const { return 1; };
+        virtual bool isVoid() const { return size() == 0; }
+        std::list<TypeDecl*>& get_forall() { return forall; }
         virtual Type *clone() const = 0;
 …
   private:
         Qualifiers tq;
         ForallList forall;
+        std::list<TypeDecl*> forall;
 };
 …
   public:
         VoidType( const Type::Qualifiers &tq );
-        virtual unsigned size() const { return 0; };
         virtual VoidType *clone() const { return new VoidType( *this ); }
 …
   public:
         StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
-        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct );
         StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 …
 class TupleType : public Type {
   public:
         TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >() );
+        TupleType( const Type::Qualifiers &tq );
         TupleType( const TupleType& );
         virtual ~TupleType();
-        typedef std::list<Type*> value_type;
-        typedef value_type::iterator iterator;
         std::list<Type*>& get_types() { return types; }
-        virtual unsigned size() const { return types.size(); };
-        iterator begin() { return types.begin(); }
-        iterator end() { return types.end(); }
         virtual TupleType *clone() const { return new TupleType( *this ); }
 …
 };
-inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
-        isConst &= other.isConst;
-        isVolatile &= other.isVolatile;
-        isRestrict &= other.isRestrict;
-        isLvalue &= other.isLvalue;
-        isAtomic &= other.isAtomic;
-        return *this;
+}
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
         isConst |= other.isConst;

src/SynTree/TypeSubstitution.cc

-              r1f44196
+              r3a2128f
 Type *TypeSubstitution::lookup( std::string formalType ) const {
         TypeEnvType::const_iterator i = typeEnv.find( formalType );
         // break on not in substitution set
         if ( i == typeEnv.end() ) return 0;
         // attempt to transitively follow TypeInstType links.
         while ( TypeInstType *actualType = dynamic_cast< TypeInstType* >( i->second ) ) {
                 const std::string& typeName = actualType->get_name();
                 // break cycles in the transitive follow
                 if ( formalType == typeName ) break;
                 // Look for the type this maps to, returning previous mapping if none-such
                 i = typeEnv.find( typeName );
                 if ( i == typeEnv.end() ) return actualType;
+        }
         // return type from substitution set
         return i->second;
 #if 0
         if ( i == typeEnv.end() ) {
 …
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         boundVars.insert( (*tyvar )->get_name() );
                 } // for
 …
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         boundVars.insert( (*tyvar )->get_name() );
                 } // for

src/SynTree/Visitor.cc

-              r1f44196
+              r3a2128f
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
         maybeAccept( applicationExpr->get_result(), *this );
+        acceptAll( applicationExpr->get_results(), *this );
         maybeAccept( applicationExpr->get_function(), *this );
         acceptAll( applicationExpr->get_args(), *this );
 …
 void Visitor::visit( UntypedExpr *untypedExpr ) {
         maybeAccept( untypedExpr->get_result(), *this );
+        acceptAll( untypedExpr->get_results(), *this );
         acceptAll( untypedExpr->get_args(), *this );
+}
 void Visitor::visit( NameExpr *nameExpr ) {
         maybeAccept( nameExpr->get_result(), *this );
+        acceptAll( nameExpr->get_results(), *this );
+}
 void Visitor::visit( AddressExpr *addressExpr ) {
         maybeAccept( addressExpr->get_result(), *this );
+        acceptAll( addressExpr->get_results(), *this );
         maybeAccept( addressExpr->get_arg(), *this );
+}
 void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
         maybeAccept( labAddressExpr->get_result(), *this );
+        acceptAll( labAddressExpr->get_results(), *this );
         maybeAccept( labAddressExpr->get_arg(), *this );
+}
 void Visitor::visit( CastExpr *castExpr ) {
         maybeAccept( castExpr->get_result(), *this );
+        acceptAll( castExpr->get_results(), *this );
         maybeAccept( castExpr->get_arg(), *this );
+}
 void Visitor::visit( UntypedMemberExpr *memberExpr ) {
         maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
-        maybeAccept( memberExpr->get_member(), *this );
+}
 void Visitor::visit( MemberExpr *memberExpr ) {
         maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
+}
 void Visitor::visit( VariableExpr *variableExpr ) {
         maybeAccept( variableExpr->get_result(), *this );
+        acceptAll( variableExpr->get_results(), *this );
+}
 void Visitor::visit( ConstantExpr *constantExpr ) {
         maybeAccept( constantExpr->get_result(), *this );
+        acceptAll( constantExpr->get_results(), *this );
         maybeAccept( constantExpr->get_constant(), *this );
+}
 void Visitor::visit( SizeofExpr *sizeofExpr ) {
         maybeAccept( sizeofExpr->get_result(), *this );
+        acceptAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 maybeAccept( sizeofExpr->get_type(), *this );
 …
 void Visitor::visit( AlignofExpr *alignofExpr ) {
         maybeAccept( alignofExpr->get_result(), *this );
+        acceptAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 maybeAccept( alignofExpr->get_type(), *this );
 …
 void Visitor::visit( UntypedOffsetofExpr *offsetofExpr ) {
         maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
+}
 void Visitor::visit( OffsetofExpr *offsetofExpr ) {
         maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
         maybeAccept( offsetofExpr->get_member(), *this );
 …
 void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
         maybeAccept( offsetPackExpr->get_result(), *this );
+        acceptAll( offsetPackExpr->get_results(), *this );
         maybeAccept( offsetPackExpr->get_type(), *this );
+}
 void Visitor::visit( AttrExpr *attrExpr ) {
         maybeAccept( attrExpr->get_result(), *this );
+        acceptAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 maybeAccept( attrExpr->get_type(), *this );
 …
 void Visitor::visit( LogicalExpr *logicalExpr ) {
         maybeAccept( logicalExpr->get_result(), *this );
+        acceptAll( logicalExpr->get_results(), *this );
         maybeAccept( logicalExpr->get_arg1(), *this );
         maybeAccept( logicalExpr->get_arg2(), *this );
 …
 void Visitor::visit( ConditionalExpr *conditionalExpr ) {
         maybeAccept( conditionalExpr->get_result(), *this );
+        acceptAll( conditionalExpr->get_results(), *this );
         maybeAccept( conditionalExpr->get_arg1(), *this );
         maybeAccept( conditionalExpr->get_arg2(), *this );
 …
 void Visitor::visit( CommaExpr *commaExpr ) {
         maybeAccept( commaExpr->get_result(), *this );
+        acceptAll( commaExpr->get_results(), *this );
         maybeAccept( commaExpr->get_arg1(), *this );
         maybeAccept( commaExpr->get_arg2(), *this );
+}
+void Visitor::visit( TupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
+void Visitor::visit( SolvedTupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
 void Visitor::visit( TypeExpr *typeExpr ) {
         maybeAccept( typeExpr->get_result(), *this );
+        acceptAll( typeExpr->get_results(), *this );
         maybeAccept( typeExpr->get_type(), *this );
+}
 …
 void Visitor::visit( ConstructorExpr * ctorExpr ) {
         maybeAccept( ctorExpr->get_result(), *this );
+        acceptAll( ctorExpr->get_results(), *this );
         maybeAccept( ctorExpr->get_callExpr(), *this );
+}
 void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
         maybeAccept( compLitExpr->get_result(), *this );
+        acceptAll( compLitExpr->get_results(), *this );
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
 …
 void Visitor::visit( UntypedValofExpr *valofExpr ) {
         maybeAccept( valofExpr->get_result(), *this );
+        acceptAll( valofExpr->get_results(), *this );
         maybeAccept( valofExpr->get_body(), *this );
+}
 …
         maybeAccept( rangeExpr->get_low(), *this );
         maybeAccept( rangeExpr->get_high(), *this );
+}
-void Visitor::visit( TupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        acceptAll( tupleExpr->get_exprs(), *this );
+}
-void Visitor::visit( TupleIndexExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_tuple(), *this );
+}
-void Visitor::visit( MemberTupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_member(), *this );
-        maybeAccept( tupleExpr->get_aggregate(), *this );
+}
-void Visitor::visit( TupleAssignExpr *assignExpr ) {
-        maybeAccept( assignExpr->get_result(), *this );
-        acceptAll( assignExpr->get_tempDecls(), *this );
-        acceptAll( assignExpr->get_assigns(), *this );
+}
-void Visitor::visit( StmtExpr *stmtExpr ) {
-        maybeAccept( stmtExpr->get_result(), *this );
-        maybeAccept( stmtExpr->get_statements(), *this );
+}
-void Visitor::visit( UniqueExpr *uniqueExpr ) {
-        maybeAccept( uniqueExpr->get_result(), *this );
-        maybeAccept( uniqueExpr->get_expr(), *this );
+}

src/SynTree/Visitor.h

-              r1f44196
+              r3a2128f
         virtual void visit( ConditionalExpr *conditionalExpr );
         virtual void visit( CommaExpr *commaExpr );
+        virtual void visit( TupleExpr *tupleExpr );
+        virtual void visit( SolvedTupleExpr *tupleExpr );
         virtual void visit( TypeExpr *typeExpr );
         virtual void visit( AsmExpr *asmExpr );
 …
         virtual void visit( UntypedValofExpr *valofExpr );
         virtual void visit( RangeExpr *rangeExpr );
-        virtual void visit( TupleExpr *tupleExpr );
-        virtual void visit( TupleIndexExpr *tupleExpr );
-        virtual void visit( MemberTupleExpr *tupleExpr );
-        virtual void visit( TupleAssignExpr *assignExpr );
-        virtual void visit( StmtExpr * stmtExpr );
-        virtual void visit( UniqueExpr * uniqueExpr );
         virtual void visit( VoidType *basicType );

src/SynTree/module.mk

r1f44196	r3a2128f
49	49	SynTree/AddStmtVisitor.cc \
50	50	SynTree/TypeSubstitution.cc \
51		SynTree/Attribute.cc \
52		SynTree/VarExprReplacer.cc
	51	SynTree/Attribute.cc
53	52

src/Tuples/TupleAssignment.cc

-              r1f44196
+              r3a2128f
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Nov 9 13:48:42 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 15:02:53 2015
 // Update Count     : 2
 //
 …
 #include "ResolvExpr/typeops.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
+#include "Tuples.h"
+#include "Explode.h"
+#include "TupleAssignment.h"
 #include "Common/SemanticError.h"
-#include "InitTweak/InitTweak.h"
 #include <functional>
 …
 #include <cassert>
 #include <set>
-#include <unordered_set>
 namespace Tuples {
+        class TupleAssignSpotter {
+          public:
+                // dispatcher for Tuple (multiple and mass) assignment operations
+                TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
+                void spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities );
+          private:
+                void match();
+                struct Matcher {
+                  public:
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        virtual ~Matcher() {}
+                        virtual void match( std::list< Expression * > &out ) = 0;
+                        ResolvExpr::AltList lhs, rhs;
+                        TupleAssignSpotter &spotter;
+                        std::list< ObjectDecl * > tmpDecls;
+                };
+                struct MassAssignMatcher : public Matcher {
+                  public:
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        virtual void match( std::list< Expression * > &out );
+                };
+                struct MultipleAssignMatcher : public Matcher {
+                  public:
+                        MultipleAssignMatcher( TupleAssignSpotter &spot, const ResolvExpr::AltList & alts );
+                        virtual void match( std::list< Expression * > &out );
+                };
+                ResolvExpr::AlternativeFinder &currentFinder;
+                std::string fname;
+                std::unique_ptr< Matcher > matcher;
+        };
+        /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
+        bool isTuple( Expression *expr ) {
+        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f )
+                : currentFinder(f), matcher(0), hasMatched( false ) {}
+        bool TupleAssignSpotter::pointsToTuple( Expression *expr ) {
+                // also check for function returning tuple of reference types
+                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(expr) )
+                        if ( isTuple(addr->get_arg() ) )
+                                return true;
+                return false;
+        }
+        bool TupleAssignSpotter::isTupleVar( DeclarationWithType *decl ) {
+                if ( dynamic_cast<TupleType *>(decl->get_type()) )
+                        return true;
+                return false;
+        }
+        bool TupleAssignSpotter::isTuple( Expression *expr, bool isRight ) {
+                // true if `expr' is an expression returning a tuple: tuple, tuple variable or MRV function
                 if ( ! expr ) return false;
+                assert( expr->has_result() );
+                return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
+        }
+        template< typename AltIter >
+        bool isMultAssign( AltIter begin, AltIter end ) {
+                // multiple assignment if more than one alternative in the range or if
+                // the alternative is a tuple
+                if ( begin == end ) return false;
+                if ( isTuple( begin->expr ) ) return true;
+                return ++begin != end;
+        }
+        bool pointsToTuple( Expression *expr ) {
+                // also check for function returning tuple of reference types
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                        return pointsToTuple( castExpr->get_arg() );
+                } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
+                        return isTuple( addr->get_arg() );
+                }
+                return false;
+        }
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
+                TupleAssignSpotter spotter( currentFinder );
+                spotter.spot( expr, possibilities );
+        }
+        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder &f )
+                : currentFinder(f) {}
+        void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
+                if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
+                        if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
+                                fname = op->get_name();
+                                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
+                                        if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
+                                                // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
+                                                continue;
+                                        }
+                                        assert( ! ali->empty() );
+                                        // grab args 2-N and group into a TupleExpr
+                                        const ResolvExpr::Alternative & alt1 = ali->front();
+                                        auto begin = std::next(ali->begin(), 1), end = ali->end();
+                                        if ( pointsToTuple(alt1.expr) ) {
+                                                if ( isMultAssign( begin, end ) ) {
+                                                        matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
+                                                } else {
+                if ( dynamic_cast<TupleExpr *>(expr) )
+                        return true;
+                else if ( VariableExpr *var = dynamic_cast<VariableExpr *>(expr) ) {
+                        if ( isTupleVar(var->get_var()) )
+                                return true;
+                }
+                return false;
+        }
+        bool TupleAssignSpotter::match() {
+                assert ( matcher != 0 );
+                std::list< Expression * > new_assigns;
+                if ( ! matcher->match(new_assigns) )
+                        return false;
+                if ( new_assigns.empty() ) return false;
+                /*return */matcher->solve( new_assigns );
+                if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+                        // now resolve new assignments
+                        std::list< Expression * > solved_assigns;
+                        ResolvExpr::AltList solved_alts;
+                        assert( currentFinder != 0 );
+                        ResolvExpr::AltList current;
+                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                                //try {
+                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                                finder.findWithAdjustment(*i);
+                                // prune expressions that don't coincide with
+                                ResolvExpr::AltList alts = finder.get_alternatives();
+                                assert( alts.size() == 1 );
+                                assert(alts.front().expr != 0 );
+                                current.push_back( finder.get_alternatives().front() );
+                                solved_assigns.push_back( alts.front().expr->clone() );
+                                //solved_assigns.back()->print(std::cerr);
+                                /*} catch( ... ) {
+                                  continue; // no reasonable alternative found
+                                  }*/
+                        }
+                        options.add_option( current );
+                        return true;
+                } else { // mass assignment
+                        //if ( new_assigns.empty() ) return false;
+                        std::list< Expression * > solved_assigns;
+                        ResolvExpr::AltList solved_alts;
+                        assert( currentFinder != 0 );
+                        ResolvExpr::AltList current;
+                        if ( optMass.empty() ) {
+                                for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+                                        optMass.push_back( ResolvExpr::AltList() );
+                        }
+                        int cnt = 0;
+                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                                finder.findWithAdjustment(*i);
+                                ResolvExpr::AltList alts = finder.get_alternatives();
+                                assert( alts.size() == 1 );
+                                assert(alts.front().expr != 0 );
+                                current.push_back( finder.get_alternatives().front() );
+                                optMass[cnt].push_back( finder.get_alternatives().front() );
+                                solved_assigns.push_back( alts.front().expr->clone() );
+                        }
+                        return true;
+                }
+                return false;
+        }
+        bool TupleAssignSpotter::isMVR( Expression *expr ) {
+                if ( expr->get_results().size() > 1 ) {
+                        // MVR processing
+                        return true;
+                }
+                return false;
+        }
+        bool TupleAssignSpotter::isTupleAssignment( UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
+                if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
+                        if ( assgnop->get_name() == std::string("?=?") ) {
+                                for ( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
+                                        assert( ali->size() == 2 );
+                                        ResolvExpr::AltList::iterator opit = ali->begin();
+                                        ResolvExpr::Alternative op1 = *opit, op2 = *(++opit);
+                                        if ( pointsToTuple(op1.expr) ) { // also handles tuple vars
+                                                if ( isTuple( op2.expr, true ) )
+                                                        matcher = new MultipleAssignMatcher(op1.expr, op2.expr);
+                                                else if ( isMVR( op2.expr ) ) {
+                                                        // handle MVR differently
+                                                } else
                                                         // mass assignment
+                                                        matcher.reset( new MassAssignMatcher( *this,  *ali ) );
+                                                        matcher = new MassAssignMatcher(op1.expr, op2.expr);
+                                                std::list< ResolvExpr::AltList > options;
+                                                if ( match() )
+                                                        /*
+                                                          if ( hasMatched ) {
+                                                          // throw SemanticError("Ambiguous tuple assignment");
+                                                          } else {*/
+                                                        // Matched for the first time
+                                                        hasMatched = true;
+                                                /*} */
+                                        } /* else if ( isTuple( op2 ) )
+                                                 throw SemanticError("Inapplicable tuple assignment.");
+                                          */
+                                }
+                                if ( hasMatched ) {
+                                        if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+                                                //options.print( std::cerr );
+                                                std::list< ResolvExpr::AltList >best = options.get_best();
+                                                if ( best.size() == 1 ) {
+                                                        std::list<Expression *> solved_assigns;
+                                                        for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ) {
+                                                                solved_assigns.push_back( i->expr );
+                                                        }
+                                                        /* assigning cost zero? */
+                                                        currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MULTIPLE*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
+                                                }
+                                                match();
+                                        } else {
+                                                assert( ! optMass.empty() );
+                                                ResolvExpr::AltList winners;
+                                                for ( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
+                                                        findMinCostAlt( i->begin(), i->end(), back_inserter(winners) );
+                                                std::list< Expression *> solved_assigns;
+                                                for ( ResolvExpr::AltList::iterator i = winners.begin(); i != winners.end(); ++i )
+                                                        solved_assigns.push_back( i->expr );
+                                                currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MASS*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
+                                        }
+                                }
+                        }
+                }
+        }
+        void TupleAssignSpotter::match() {
+                assert ( matcher != 0 );
+                std::list< Expression * > new_assigns;
+                matcher->match( new_assigns );
+                if ( new_assigns.empty() ) return;
+                ResolvExpr::AltList current;
+                // now resolve new assignments
+                for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                        ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
+                        try {
+                                finder.findWithAdjustment(*i);
+                        } catch (...) {
+                                return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
+                return hasMatched;
+        }
+        void TupleAssignSpotter::Matcher::init( Expression *_lhs, Expression *_rhs ) {
+                lhs.clear();
+                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(_lhs) )
+                        if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
+                                std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(lhs) );
+                rhs.clear();
+        }
+        TupleAssignSpotter::Matcher::Matcher( /*TupleAssignSpotter &spot,*/ Expression *_lhs, Expression *_rhs ) /*: own_spotter(spot) */{
+                init(_lhs,_rhs);
+        }
+        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( Expression *_lhs, Expression *_rhs )/* : own_spotter(spot) */{
+                init(_lhs,_rhs);
+                if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(_rhs) )
+                        std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(rhs) );
+        }
+        UntypedExpr *TupleAssignSpotter::Matcher::createAssgn( Expression *left, Expression *right ) {
+                if ( left && right ) {
+                        std::list< Expression * > args;
+                        args.push_back(new AddressExpr(left->clone()));  args.push_back(right->clone());
+                        return new UntypedExpr(new NameExpr("?=?"), args);
+                } else
+                        throw 0; // xxx - diagnose the problem
+        }
+        bool TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
+                if ( lhs.empty() || (rhs.size() != 1) ) return false;
+                for ( std::list< Expression * >::iterator l = lhs.begin(); l != lhs.end(); l++ ) {
+                        std::list< Expression * > args;
+                        args.push_back( new AddressExpr(*l) );
+                        args.push_back( rhs.front() );
+                        out.push_back( new UntypedExpr(new NameExpr("?=?"), args) );
+                }
+                return true;
+        }
+        bool TupleAssignSpotter::MassAssignMatcher::solve( std::list< Expression * > &assigns ) {
+                /*
+                  std::list< Expression * > solved_assigns;
+                  ResolvExpr::AltList solved_alts;
+                  assert( currentFinder != 0 );
+                  ResolvExpr::AltList current;
+                  if ( optMass.empty() ) {
+                  for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+                  optMass.push_back( ResolvExpr::AltList() );
+                  }
+                  int cnt = 0;
+                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                  finder.findWithAdjustment(*i);
+                  ResolvExpr::AltList alts = finder.get_alternatives();
+                  assert( alts.size() == 1 );
+                  assert(alts.front().expr != 0 );
+                  current.push_back( finder.get_alternatives().front() );
+                  optMass[cnt].push_back( finder.get_alternatives().front() );
+                  solved_assigns.push_back( alts.front().expr->clone() );
+                  }
+                */
+                return true;
+        }
+        bool TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
+                // need more complicated matching
+                if ( lhs.size() == rhs.size() ) {
+                        zipWith( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), back_inserter(out), TupleAssignSpotter::Matcher::createAssgn );
+                        return true;
+                } //else
+                //std::cerr << "The length of (left, right) is: (" << lhs.size() << "," << rhs.size() << ")" << std::endl;*/
+                return false;
+        }
+        bool TupleAssignSpotter::MultipleAssignMatcher::solve( std::list< Expression * > &assigns ) {
+                /*
+                  std::list< Expression * > solved_assigns;
+                  ResolvExpr::AltList solved_alts;
+                  assert( currentFinder != 0 );
+                  ResolvExpr::AltList current;
+                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                  //try {
+                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                  finder.findWithAdjustment(*i);
+                  // prune expressions that don't coincide with
+                  ResolvExpr::AltList alts = finder.get_alternatives();
+                  assert( alts.size() == 1 );
+                  assert(alts.front().expr != 0 );
+                  current.push_back( finder.get_alternatives().front() );
+                  solved_assigns.push_back( alts.front().expr->clone() );
+                  //solved_assigns.back()->print(std::cerr);
+                  //} catch( ... ) {
+                  //continue; // no reasonable alternative found
+                  //}
+                  }
+                  options.add_option( current );
+                */
+                return true;
+        }
+        void TupleAssignSpotter::Options::add_option( ResolvExpr::AltList &opt ) {
+                using namespace std;
+                options.push_back( opt );
+                /*
+                  vector< Cost > costs;
+                  costs.reserve( opt.size() );
+                  transform( opt.begin(), opt.end(), back_inserter(costs), ptr_fun(extract_cost) );
+                */
+                // transpose matrix
+                if ( costMatrix.empty() )
+                        for ( unsigned int i = 0; i< opt.size(); ++i)
+                                costMatrix.push_back( vector<ResolvExpr::Cost>() );
+                int cnt = 0;
+                for ( ResolvExpr::AltList::iterator i = opt.begin(); i != opt.end(); ++i, cnt++ )
+                        costMatrix[cnt].push_back( i->cost );
+                return;
+        }
+        std::list< ResolvExpr::AltList > TupleAssignSpotter::Options::get_best() {
+                using namespace std;
+                using namespace ResolvExpr;
+                list< ResolvExpr::AltList > ret;
+                list< multiset<int> > solns;
+                for ( vector< vector<Cost> >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+                        list<int> current;
+                        findMinCost( i->begin(), i->end(), back_inserter(current) );
+                        solns.push_back( multiset<int>(current.begin(), current.end()) );
+                }
+                // need to combine
+                multiset<int> result;
+                lift_intersection( solns.begin(), solns.end(), inserter( result, result.begin() ) );
+                if ( result.size() != 1 )
+                        throw SemanticError("Ambiguous tuple expression");
+                ret.push_back(get_option( *(result.begin() )));
+                return ret;
+        }
+        void TupleAssignSpotter::Options::print( std::ostream &ostr ) {
+                using namespace std;
+                for ( vector< vector < ResolvExpr::Cost > >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+                        for ( vector < ResolvExpr::Cost >::iterator j = i->begin(); j != i->end(); ++j )
+                                ostr << *j << " " ;
+                        ostr << std::endl;
+                } // for
+                return;
+        }
+        ResolvExpr::Cost extract_cost( ResolvExpr::Alternative &alt ) {
+                return alt.cost;
+        }
+        template< typename InputIterator, typename OutputIterator >
+        void TupleAssignSpotter::Options::findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
+                using namespace ResolvExpr;
+                std::list<int> alternatives;
+                // select the alternatives that have the minimum parameter cost
+                Cost minCost = Cost::infinity;
+                unsigned int index = 0;
+                for ( InputIterator i = begin; i != end; ++i, index++ ) {
+                        if ( *i < minCost ) {
+                                minCost = *i;
+                                alternatives.clear();
+                                alternatives.push_back( index );
+                        } else if ( *i == minCost ) {
+                                alternatives.push_back( index );
+                        }
+                        // prune expressions that don't coincide with
+                        ResolvExpr::AltList alts = finder.get_alternatives();
+                        assert( alts.size() == 1 );
+                        assert( alts.front().expr != 0 );
+                        current.push_back( alts.front() );
+                }
+                // extract expressions from the assignment alternatives to produce a list of assignments that
+                // together form a single alternative
+                std::list< Expression *> solved_assigns;
+                for ( ResolvExpr::Alternative & alt : current ) {
+                        solved_assigns.push_back( alt.expr->clone() );
+                }
+                // xxx - need to do this??
+                ResolvExpr::TypeEnvironment compositeEnv;
+                simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
+        }
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter) {
+                assert( ! alts.empty() );
+                ResolvExpr::Alternative lhsAlt = alts.front();
+                // peel off the cast that exists on ctor/dtor expressions
+                bool isCast = false;
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
+                        lhsAlt.expr = castExpr->get_arg();
+                        castExpr->set_arg( nullptr );
+                        delete castExpr;
+                        isCast = true;
+                }
+                // explode the lhs so that each field of the tuple-valued-expr is assigned.
+                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs) );
+                // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
+                if ( isCast ) {
+                        for ( ResolvExpr::Alternative & alt : lhs ) {
+                                Expression *& expr = alt.expr;
+                                Type * castType = expr->get_result()->clone();
+                                Type * type = InitTweak::getPointerBase( castType );
+                                assert( type );
+                                type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+                                type->set_isLvalue( true ); // xxx - might not need this
+                                expr = new CastExpr( expr, castType );
+                        }
+                }
+        }
+        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
+                assert( alts.size() == 1 || alts.size() == 2 );
+                if ( alts.size() == 2 ) {
+                        rhs.push_back( alts.back() );
+                }
+        }
+        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
+                // explode the rhs so that each field of the tuple-valued-expr is assigned.
+                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs) );
+        }
+        UntypedExpr * createFunc( const std::string &fname, ObjectDecl *left, ObjectDecl *right ) {
+                assert( left );
+                std::list< Expression * > args;
+                args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
+                // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
+                if ( right ) args.push_back( new VariableExpr( right ) );
+                return new UntypedExpr( new NameExpr( fname ), args );
+        }
+        ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
+                assert( expr->has_result() && ! expr->get_result()->isVoid() );
+                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+        }
+        void TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
+                static UniqueName lhsNamer( "__massassign_L" );
+                static UniqueName rhsNamer( "__massassign_R" );
+                assert ( ! lhs.empty() && rhs.size() <= 1);
+                ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
+                for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
+                        ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
+                        out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
+                        tmpDecls.push_back( ltmp );
+                }
+                if ( rtmp ) tmpDecls.push_back( rtmp );
+        }
+        void TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
+                static UniqueName lhsNamer( "__multassign_L" );
+                static UniqueName rhsNamer( "__multassign_R" );
+                // xxx - need more complicated matching?
+                if ( lhs.size() == rhs.size() ) {
+                        std::list< ObjectDecl * > ltmp;
+                        std::list< ObjectDecl * > rtmp;
+                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
+                                return newObject( lhsNamer, alt.expr );
+                        });
+                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( ResolvExpr::Alternative & alt ){
+                                return newObject( rhsNamer, alt.expr );
+                        });
+                        zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
+                        tmpDecls.splice( tmpDecls.end(), ltmp );
+                        tmpDecls.splice( tmpDecls.end(), rtmp );
+                }
+                }
+                std::copy( alternatives.begin(), alternatives.end(), out );
+        }
+        template< class InputIterator, class OutputIterator >
+        void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ) {
+                if ( begin == end ) return;
+                InputIterator test = begin;
+                if (++test == end)
+                        { copy(begin->begin(), begin->end(), out); return; }
+                std::multiset<int> cur; // InputIterator::value_type::value_type
+                copy( begin->begin(), begin->end(), inserter( cur, cur.begin() ) );
+                while ( test != end ) {
+                        std::multiset<int> temp;
+                        set_intersection( cur.begin(), cur.end(), test->begin(), test->end(), inserter(temp,temp.begin()) );
+                        cur.clear();
+                        copy( temp.begin(), temp.end(), inserter(cur,cur.begin()));
+                        ++test;
+                }
+                copy( cur.begin(), cur.end(), out );
+                return;
+        }
+        ResolvExpr::AltList TupleAssignSpotter::Options::get_option( std::list< ResolvExpr::AltList >::size_type index ) {
+                if ( index >= options.size() )
+                        throw 0; // XXX
+                std::list< ResolvExpr::AltList >::iterator it = options.begin();
+                for ( std::list< ResolvExpr::AltList >::size_type i = 0; i < index; ++i, ++it );
+                return *it;
+        }
 } // namespace Tuples

src/Tuples/module.mk

-              r1f44196
+              r3a2128f
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
 SRC +=  Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc
+        Tuples/NameMatcher.cc

src/driver/cfa.cc

r1f44196	r3a2128f
244	244	nargs += 1;
245	245	} // if
246		~~args[nargs] = "-I" CFA_INCDIR "/concurrency";~~
247		~~nargs += 1;~~
248	246	args[nargs] = "-I" CFA_INCDIR "/containers";
249	247	nargs += 1;

src/libcfa/Makefile.am

-              r1f44196
+              r3a2128f
 CC = ${abs_top_srcdir}/src/driver/cfa
+headers = limits stdlib math iostream fstream iterator rational assert containers/vector concurrency/threads
+runtimehdrs = concurrency
+headers = limits stdlib math iostream fstream iterator rational containers/vector
 libobjs = ${headers:=.o}

src/libcfa/Makefile.in

-              r1f44196
+              r3a2128f
 am__objects_1 = limits.$(OBJEXT) stdlib.$(OBJEXT) math.$(OBJEXT) \
         iostream.$(OBJEXT) fstream.$(OBJEXT) iterator.$(OBJEXT) \
+        rational.$(OBJEXT) assert.$(OBJEXT) \
+        containers/vector.$(OBJEXT) concurrency/threads.$(OBJEXT)
+        rational.$(OBJEXT) containers/vector.$(OBJEXT)
 am_libcfa_a_OBJECTS = libcfa-prelude.$(OBJEXT) $(am__objects_1)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
 …
 cfalib_DATA = builtins.cf extras.cf prelude.cf
 MAINTAINERCLEANFILES = builtins.cf extras.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+headers = limits stdlib math iostream fstream iterator rational assert containers/vector concurrency/threads
+runtimehdrs = concurrency
+headers = limits stdlib math iostream fstream iterator rational containers/vector
 libobjs = ${headers:=.o}
 libcfa_a_SOURCES = libcfa-prelude.c ${headers:=.c}
 …
 containers/vector.$(OBJEXT): containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
-concurrency/$(am__dirstamp):
-        @$(MKDIR_P) concurrency
-        @: > concurrency/$(am__dirstamp)
-concurrency/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) concurrency/$(DEPDIR)
-        @: > concurrency/$(DEPDIR)/$(am__dirstamp)
-concurrency/threads.$(OBJEXT): concurrency/$(am__dirstamp) \
-        concurrency/$(DEPDIR)/$(am__dirstamp)
 libcfa.a: $(libcfa_a_OBJECTS) $(libcfa_a_DEPENDENCIES) $(EXTRA_libcfa_a_DEPENDENCIES)
         $(AM_V_at)-rm -f libcfa.a
 …
 mostlyclean-compile:
         -rm -f *.$(OBJEXT)
-        -rm -f concurrency/threads.$(OBJEXT)
         -rm -f containers/vector.$(OBJEXT)
 …
         -rm -f *.tab.c
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/assert.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstream.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iostream.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rational.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdlib.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/threads.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/vector.Po@am__quote@
 …
         -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
         -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
-        -rm -f concurrency/$(DEPDIR)/$(am__dirstamp)
-        -rm -f concurrency/$(am__dirstamp)
         -rm -f containers/$(DEPDIR)/$(am__dirstamp)
         -rm -f containers/$(am__dirstamp)
 …
 distclean: distclean-am
         -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) containers/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 …
 maintainer-clean: maintainer-clean-am
         -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) containers/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic \

src/main.cc

-              r1f44196
+              r3a2128f
 #include "Common/UnimplementedError.h"
 #include "../config.h"
-#include "Tuples/Tuples.h"
 using namespace std;
 …
                 OPTPRINT( "tweakInit" )
                 InitTweak::genInit( translationUnit );
+                OPTPRINT( "expandMemberTuples" );
+                Tuples::expandMemberTuples( translationUnit );
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
 …
                         return 0;
                 } // if
-                OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
-                Tuples::expandUniqueExpr( translationUnit );
                 OPTPRINT("instantiateGenerics")
 …
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
-                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
-                Tuples::expandTuples( translationUnit );
                 // print tree right before code generation

Context Navigation

Changes in / [1f44196:3a2128f]

Legend:

Download in other formats: