Changeset 6603c1d

Timestamp:

Aug 15, 2016, 10:18:22 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b1848a0

Parents:

38736854 (diff), 797347f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Files:

• doc/LaTeXmacros/common.tex (modified) (3 diffs)
• doc/aaron_comp_II/comp_II.tex (modified) (5 diffs)
• doc/bibliography/cfa.bib (modified) (2 diffs)
• doc/user/user.tex (modified) (32 diffs)
• src/Parser/DeclarationNode.cc (modified) (6 diffs)
• src/Parser/ExpressionNode.cc (modified) (2 diffs)
• src/Parser/InitializerNode.cc (modified) (5 diffs)
• src/Parser/ParseNode.cc (modified) (3 diffs)
• src/Parser/ParseNode.h (modified) (12 diffs)
• src/Parser/StatementNode.cc (modified) (12 diffs)
• src/Parser/TypeData.cc (modified) (3 diffs)
• src/Parser/parser.cc (modified) (289 diffs)
• src/Parser/parser.yy (modified) (27 diffs)
• src/SynTree/Statement.cc (modified) (2 diffs)
• src/SynTree/Statement.h (modified) (2 diffs)
• src/tests/.expect/32/extension.txt (modified) (1 diff)
• src/tests/.expect/32/gccExtensions.txt (modified) (2 diffs)
• src/tests/.expect/64/gccExtensions.txt (modified) (1 diff)
• src/tests/exception.c (modified) (2 diffs)
• src/tests/gccExtensions.c (modified) (3 diffs)

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Aug  2 17:02:02 2016
-%% Update Count     : 228
+%% Last Modified On : Sun Aug 14 08:27:29 2016
+%% Update Count     : 231
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -153 +153 @@
         {\abbrevFont{etc}.\xspace}%
 }%
+\newcommand{\etal}{%
+        \@ifnextchar{.}{\abbrevFont{et~al}}%
+                {\abbrevFont{et al}.\xspace}%
+}%
 \makeatother
 
@@ -251 +255 @@
 literate={-}{\raisebox{-0.15ex}{\texttt{-}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
         {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {_}{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
-        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {...}{$\dots$}2,
+        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2,
 }%
 

doc/aaron_comp_II/comp_II.tex

@@ -413 +413 @@
 \subsection{Argument-Parameter Matching}
 The first axis for consideration is argument-parameter matching direction --- whether the type matching for a candidate function to a set of candidate arguments is directed by the argument types or the parameter types. 
+For programming languages without implicit conversions, argument-parameter matching is essentially the entirety of the expression resolution problem, and is generally referred to as ``overload resolution'' in the literature.
 All expression resolution algorithms form a DAG of interpretations, some explicitly, some implicitly; in this DAG, arcs point from function-call interpretations to argument interpretations, as below:
 \begin{figure}[h]
@@ -422 +423 @@
 
 double *f(int*, int*); // $f_d$
-char *f(char*, char*); // $f_c$
+char *f(char*, int*); // $f_c$
 
 f( f( p, p ), p );
@@ -463 +464 @@
 Deciding when to switch between bottom-up and top-down resolution to minimize wasted work in a hybrid algorithm is a necessarily heuristic process, and though finding good heuristics for which subexpressions to swich matching strategies on is an open question, one reasonable approach might be to set a threshold $t$ for the number of candidate functions, and to use top-down resolution for any subexpression with fewer than $t$ candidate functions, to minimize the number of unmatchable argument interpretations computed, but to use bottom-up resolution for any subexpression with at least $t$ candidate functions, to reduce duplication in argument interpretation computation between the different candidate functions. 
 
+Ganzinger and Ripken~\cite{Ganzinger80} propose an approach (later refined by Pennello~\etal~\cite{Pennello80}) that uses a top-down filtering pass followed by a bottom-up filtering pass to reduce the number of candidate interpretations; they prove that for the Ada programming language a small number of such iterations is sufficient to converge to a solution for the expression resolution problem. 
+Persch~\etal~\cite{PW:overload} developed a similar two-pass approach where the bottom-up pass is followed by the top-down pass. 
+These algorithms differ from the hybrid approach under investigation in that they take multiple passes over the expression tree to yield a solution, and also in that they apply both filtering heuristics to all expression nodes; \CFA's polymorphic functions and implicit conversions make the approach of filtering out invalid types taken by all of these algorithms infeasible.
+
 \subsubsection{Common Subexpression Caching}
 With any of these argument-parameter approaches, it may be a useful optimization to cache the resolution results for common subexpressions; in Figure~\ref{fig:res_dag} this optimization would result in the list of interpretations $[p_c, p_i]$ for ©p© only being calculated once, and re-used for each of the three instances of ©p©.
 
 \subsection{Implicit Conversion Application}
-Baker's and Cormack's algorithms do not account for implicit conversions\footnote{Baker does briefly comment on an approach for handling implicit conversions, but does not provide an implementable algorithm.}; both assume that there is at most one valid interpretation of a given expression for each distinct type.
-Integrating implicit conversion handling into their algorithms provides some choice of implementation approach. 
+With the exception of Bilson, the authors mentioned above do not account for implicit conversions in their algorithms\footnote{Baker does briefly comment on an approach for handling implicit conversions, but does not provide an implementable algorithm.}; all assume that there is at most one valid interpretation of a given expression for each distinct type. 
+Integrating implicit conversion handling into the presented argument-parameter matching algorithms thus provides some choice of implementation approach.
+
+Inference of polymorphic type variables can be considered a form of implicit conversion application, where monomorphic types are implicitly converted to instances of some polymorphic type\footnote{This ``conversion'' may not be implemented in any explicit way at runtime, but does need to be handled by the expression resolver as an inexact match between argument and parameter types.}. 
+This form of implicit conversion is particularly common in functional languages; Haskell's type classes~\cite{typeclass} are a particularly well-studied variant of this inference. 
+However, type classes arguably do not allow name overloading, as (at least in the Haskell implmentation) identifiers belonging to type classes may not be overloaded in any other context than an implementation of that type class; this provides a single (possibly polymorphic) interpretation of any identifier, simplifing the expression resolution problem relative to \CFA. 
+\CC~\cite{ANSI98:C++} includes both name overloading and implicit conversions in its expression resolution specification, though unlike \CFA it does complete type-checking on a generated monomorphization of template functions, where \CFA simply checks a list of type constraints. 
+The upcoming Concepts standard~\cite{C++concepts} defines a system of type constraints similar in principle to \CFA's.
+Cormack and Wright~\cite{Cormack90} present an algorithm which integrates overload resolution with a polymorphic type inference approach very similar to \CFA's.
+However, their algorithm does not account for implicit conversions other than polymorphic type binding and their discussion of their overload resolution algorithm is not sufficiently detailed to classify it with the other argument-parameter matching approaches\footnote{Their overload resolution algorithm is possibly a variant of Ganzinger and Ripken~\cite{Ganzinger80} or Pennello~\etal~\cite{Pennello80}, modified to allow for polymorphic type binding.}.
 
 \subsubsection{On Parameters}
-Bilson does account for implicit conversions in his algorithm, but it is unclear the approach is optimal. 
+Bilson does account for implicit conversions in his algorithm, but it is unclear if the approach is optimal. 
 His algorithm integrates checking for valid implicit conversions into the argument-parameter-matching step, essentially trading more expensive matching for a smaller number of argument interpretations. 
 This approach may result in the same subexpression being checked for a type match with the same type multiple times, though again memoization may mitigate this cost, and this approach does not generate implicit conversions that are not useful to match the containing function. 
@@ -484 +497 @@
 
 \subsection{Candidate Set Generation}
-Cormack, Baker and Bilson all generate the complete set of candidate argument interpretations before attempting to match the containing function call expression. 
+All the algorithms discussed to this point generate the complete set of candidate argument interpretations before attempting to match the containing function call expression. 
 However, given that the top-level expression interpretation that is ultimately chosen is the minimal-cost valid interpretation, any consideration of non-minimal-cost interpretations is in some sense wasted work.
 Under the assumption that that programmers generally write function calls with relatively low-cost interpretations, a possible work-saving heuristic is to generate only the lowest-cost argument interpretations first, attempt to find a valid top-level interpretation using them, and only if that fails generate the next higher-cost argument interpretations.
 
 \subsubsection{Eager}
-Within the eager approach taken by Cormack, Baker and Bilson, there are still variants to explore. 
+Within the eager approach taken by the existing top-down and bottom-up algorithms, there are still variants to explore. 
 Cormack and Baker do not account for implict conversions, and thus do not account for the possibility of multiple valid interpretations with distinct costs; Bilson, on the other hand, sorts the list of interpretations to aid in finding minimal-cost interpretations. 
 Sorting the lists of argument or function call interpretations by cost at some point during resolution may provide useful opportunities to short-circuit expression evaluation when a minimal-cost interpretation is found, though it is unclear if this short-circuiting behaviour justifies the cost of the sort.
@@ -559 +572 @@
 
 This proposed project should provide valuable data on how to implement a performant compiler for modern programming languages such as \CFA with powerful static type-systems, specifically targeting the feature interaction between name overloading and implicit conversions. 
-This work is not limited in applicability to \CFA, but may also be useful for supporting efficient compilation of the upcoming ``Concepts'' standard~\cite{C++concepts} for \CC template constraints, for instance. 
+This work is not limited in applicability to \CFA, but may also be useful for supporting efficient compilation of the upcoming Concepts standard~\cite{C++concepts} for \CC template constraints, for instance. 
 
 \appendix

doc/bibliography/cfa.bib

@@ -4685 +4685 @@
 }
 
+@article{Ganzinger80,
+        contributer = {a3moss@uwaterloo.ca},
+        author = {Ganzinger, Harald and Ripken, Knut},
+        title = {Operator Identification in {ADA}: Formal Specification, Complexity, and Concrete Implementation},
+        journal = {SIGPLAN Notices},
+        issue_date = {February 1980},
+        volume = {15},
+        number = {2},
+        month = feb,
+        year = {1980},
+        issn = {0362-1340},
+        pages = {30--42},
+        numpages = {13},
+        url = {http://doi.acm.org/10.1145/947586.947589},
+        doi = {10.1145/947586.947589},
+        publisher = {ACM},
+        address = {New York, NY, USA}
+}
+
 @article{Ford82,
     keywords    = {},
@@ -5851 +5870 @@
 }
 
+@article{Pennello80,
+        contributer = {a3moss@uwaterloo.ca},
+        author = {Pennello, Tom and DeRemer, Frank and Meyers, Richard},
+        title = {A Simplified Operator Identification Scheme for {Ada}},
+        journal = {SIGPLAN Notices},
+        issue_date = {July-August 1980},
+        volume = {15},
+        number = {7 and 8},
+        month = jul,
+        year = {1980},
+        issn = {0362-1340},
+        pages = {82--87},
+        numpages = {6},
+        url = {http://doi.acm.org/10.1145/947680.947688},
+        doi = {10.1145/947680.947688},
+        publisher = {ACM},
+        address = {New York, NY, USA},
+}
+
 @inproceedings{Dice10,
     keywords    = {hardware, synchronization, transactional memory},

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Aug  2 17:39:02 2016
-%% Update Count     : 1286
+%% Last Modified On : Sun Aug 14 08:23:06 2016
+%% Update Count     : 1323
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -317 +317 @@
 
 \item
-\Indexc{-no-include-std}\index{compilation option!-no-include-std@©-no-include-std©}
+\Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
 \textbf{This option is \emph{not} the default.}
@@ -807 +807 @@
 
 
+\section{Backquote Identifiers}
+\label{s:BackquoteIdentifiers}
+
+\CFA accommodates keyword clashes by syntactic transformations using the \CFA backquote escape-mechanism:
+\begin{lstlisting}
+int `otype` = 3;                                // make keyword an identifier
+double `choose` = 3.5;
+\end{lstlisting}
+Programs can be converted easily by enclosing keyword identifiers in backquotes, and the backquotes can be removed later when the identifier name is changed to an non-keyword name.
+Clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled automatically using the preprocessor, ©#include_next© and ©-I filename©:
+\begin{lstlisting}
+// include file uses the CFA keyword "otype".
+#if ! defined( otype )                  // nesting ?
+#define otype `otype`
+#define __CFA_BFD_H__
+#endif // ! otype
+
+#include_next <bfd.h>                   // must have internal check for multiple expansion
+
+#if defined( otype ) && defined( __CFA_BFD_H__ )        // reset only if set
+#undef otype
+#undef __CFA_BFD_H__
+#endif // otype && __CFA_BFD_H__
+\end{lstlisting}
+
+
 \section{Type Operators}
 
@@ -1011 +1037 @@
 Alternatively, prototype definitions can be eliminated by using a two-pass compilation, and implicitly creating header files for exports.
 The former is easy to do, while the latter is more complex.
-Currently, \CFA does \emph{not} attempt to support named arguments.
+
+Furthermore, named arguments do not work well in a \CFA-style programming-languages because they potentially introduces a new criteria for type matching.
+For example, it is technically possible to disambiguate between these two overloaded definitions of ©f© based on named arguments at the call site:
+\begin{lstlisting}
+int f( int i, int j );
+int f( int x, double y );
+
+f( j : 3, i : 4 );                              §\C{// 1st f}§
+f( x : 7, y : 8.1 );                    §\C{// 2nd f}§
+f( 4, 5 );                                              §\C{// ambiguous call}§
+\end{lstlisting}
+However, named arguments compound routine resolution in conjunction with conversions:
+\begin{lstlisting}
+f( i : 3, 5.7 );                                §\C{// ambiguous call ?}§
+\end{lstlisting}
+Depending on the cost associated with named arguments, this call could be resolvable or ambiguous.
+Adding named argument into the routine resolution algorithm does not seem worth the complexity.
+Therefore, \CFA does \emph{not} attempt to support named arguments.
 
 \item[Default Arguments]
@@ -1021 +1064 @@
 the allowable positional calls are:
 \begin{lstlisting}
-p();                            §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
-p( 4 );                         §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
-p( 4, 4 );                      §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
-p( 4, 4, 4 );           §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
+p();                                                    §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
+p( 4 );                                                 §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
+p( 4, 4 );                                              §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
+p( 4, 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
 // empty arguments
-p(  , 4, 4 );           §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
-p( 4,  , 4 );           §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
-p( 4, 4,   );           §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
-p( 4,  ,   );           §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
-p(  , 4,   );           §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
-p(  ,  , 4 );           §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
-p(  ,  ,   );           §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
+p(  , 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
+p( 4,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
+p( 4, 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
+p( 4,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
+p(  , 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
+p(  ,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
+p(  ,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
 \end{lstlisting}
 Here the missing arguments are inserted from the default values in the parameter list.
@@ -1067 +1110 @@
 The conflict occurs because both named and ellipse arguments must appear after positional arguments, giving two possibilities:
 \begin{lstlisting}
-p( /* positional */, . . ., /* named */ );
-p( /* positional */, /* named */, . . . );
+p( /* positional */, ... , /* named */ );
+p( /* positional */, /* named */, ... );
 \end{lstlisting}
 While it is possible to implement both approaches, the first possibly is more complex than the second, \eg:
 \begin{lstlisting}
-p( int x, int y, int z, . . . );
-p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, . . ., /* named */ );}§
-p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, . . . );}§
+p( int x, int y, int z, ... );
+p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
+p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
 \end{lstlisting}
 In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin.
@@ -1082 +1125 @@
 The problem is exacerbated with default arguments, \eg:
 \begin{lstlisting}
-void p( int x, int y = 2, int z = 3. . . );
-p( 1, 4, 5, 6, z : 3 );         §\C{// assume p( /* positional */, . . ., /* named */ );}§
-p( 1, z : 3, 4, 5, 6 );         §\C{// assume p( /* positional */, /* named */, . . . );}§
+void p( int x, int y = 2, int z = 3... );
+p( 1, 4, 5, 6, z : 3 );         §\C{// assume p( /* positional */, ... , /* named */ );}§
+p( 1, z : 3, 4, 5, 6 );         §\C{// assume p( /* positional */, /* named */, ... );}§
 \end{lstlisting}
 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments;
@@ -1129 +1172 @@
 \subsection{Type Nesting}
 
-\CFA allows \Index{type nesting}, and type qualification of the nested types (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
+\CFA allows \Index{type nesting}, and type qualification of the nested typres (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
 \begin{figure}
+\centering
 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
@@ -1397 +1441 @@
 Mass assignment has the following form:
 \begin{lstlisting}
-[ §\emph{lvalue}§, ..., §\emph{lvalue}§ ] = §\emph{expr}§;
+[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
 \end{lstlisting}
 \index{lvalue}
@@ -1437 +1481 @@
 Multiple assignment has the following form:
 \begin{lstlisting}
-[ §\emph{lvalue}§, . . ., §\emph{lvalue}§ ] = [ §\emph{expr}§, . . ., §\emph{expr}§ ];
+[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
 \end{lstlisting}
 \index{lvalue}
@@ -1873 +1917 @@
 \begin{lstlisting}
 switch ( i ) {
-  ®case 1, 3, 5®:
+  case ®1, 3, 5®:
         ...
-  ®case 2, 4, 6®:
+  case ®2, 4, 6®:
         ...
 }
@@ -1906 +1950 @@
 \begin{lstlisting}
 switch ( i ) {
-  ®case 1~5:®
+  case ®1~5:®
         ...
-  ®case 10~15:®
+  case ®10~15:®
         ...
 }
@@ -1915 +1959 @@
 \begin{lstlisting}
 switch ( i )
-  case 1 ... 5:
+  case ®1 ... 5®:
         ...
-  case 10 ... 15:
+  case ®10 ... 15®:
         ...
 }
@@ -4369 +4413 @@
 
 
+\section{Incompatible}
+
+The following incompatibles exist between \CFA and C, and are similar to Annex C for \CC~\cite{ANSI14:C++}.
+
+\begin{enumerate}
+\item
+\begin{description}
+\item[Change:] add new keywords \\
+New keywords are added to \CFA (see~\VRef{s:NewKeywords}).
+\item[Rationale:] keywords added to implement new semantics of \CFA.
+\item[Effect on original feature:] change to semantics of well-defined feature. \\
+Any ISO C programs using these keywords as identifiers are invalid \CFA programs.
+\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism (see~\VRef{s:BackquoteIdentifiers}):
+\item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare.
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] type of character literal ©int© to ©char© to allow more intuitive overloading:
+\begin{lstlisting}
+int rtn( int i );
+int rtn( char c );
+rtn( 'x' );                                             §\C{// programmer expects 2nd rtn to be called}§
+\end{lstlisting}
+\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
+In particular, output of ©char© variable now print a character rather than the decimal ASCII value of the character.
+\begin{lstlisting}
+sout | 'x' | " " | (int)'x' | endl;
+x 120
+\end{lstlisting}
+Having to cast ©'x'© to ©char© is non-intuitive.
+\item[Effect on original feature:] change to semantics of well-defined feature that depend on:
+\begin{lstlisting}
+sizeof( 'x' ) == sizeof( int )
+\end{lstlisting}
+no long work the same in \CFA programs.
+\item[Difficulty of converting:] simple
+\item[How widely used:] programs that depend upon ©sizeof( 'x' )© are rare and can be changed to ©sizeof(char)©.
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] make string literals ©const©:
+\begin{lstlisting}
+char * p = "abc";                               §\C{// valid in C, deprecated in \CFA}§
+char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
+\end{lstlisting}
+The type of a string literal is changed from ©[] char© to ©const [] char©.
+Similarly, the type of a wide string literal is changed from ©[] wchar_t© to ©const [] wchar_t©.
+\item[Rationale:] This change is a safety issue:
+\begin{lstlisting}
+char * p = "abc";
+p[0] = 'w';                                             §\C{// segment fault or change constant literal}§
+\end{lstlisting}
+The same problem occurs when passing a string literal to a routine that changes its argument.
+\item[Effect on original feature:] change to semantics of well-defined feature.
+\item[Difficulty of converting:] simple syntactic transformation, because string literals can be converted to ©char *©.
+\item[How widely used:] programs that have a legitimate reason to treat string literals as pointers to potentially modifiable memory are rare.
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
+\begin{lstlisting}
+int i;                                                  §\C{// forward definition}§
+int *j = ®&i®;                                  §\C{// forward reference, valid in C, invalid in \CFA}§
+int i = 0;                                              §\C{// definition}§
+\end{lstlisting}
+is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
+This change makes it impossible to define mutually referential file-local static objects, if initializers are restricted to the syntactic forms of C. For example,
+\begin{lstlisting}
+struct X { int i; struct X *next; };
+static struct X a;                              §\C{// forward definition}§
+static struct X b = { 0, ®&a® };        §\C{// forward reference, valid in C, invalid in \CFA}§
+static struct X a = { 1, &b };  §\C{// definition}§
+\end{lstlisting}
+\item[Rationale:] avoids having different initialization rules for builtin types and userdefined types.
+\item[Effect on original feature:] change to semantics of well-defined feature.
+\item[Difficulty of converting:] the initializer for one of a set of mutually-referential file-local static objects must invoke a routine call to achieve the initialization.
+\item[How widely used:] seldom
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] have ©struct© introduce a scope for nested types:
+\begin{lstlisting}
+enum ®Colour® { R, G, B, Y, C, M };
+struct Person {
+        enum ®Colour® { R, G, B };      §\C{// nested type}§
+        struct Face {                           §\C{// nested type}§
+                ®Colour® Eyes, Hair;    §\C{// type defined outside (1 level)}§
+        };
+        ß.ß®Colour® shirt;                      §\C{// type defined outside (top level)}§
+        ®Colour® pants;                         §\C{// type defined same level}§
+        Face looks[10];                         §\C{// type defined same level}§
+};
+®Colour® c = R;                                 §\C{// type/enum defined same level}§
+Personß.ß®Colour® pc = Personß.ßR;      §\C{// type/enum defined inside}§
+Personß.ßFace pretty;                   §\C{// type defined inside}§
+\end{lstlisting}
+In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, i.e., the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
+\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \Index*[C++]{\CC}.
+Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''.
+\item[Rationale:] ©struct© scope is crucial to \CFA as an information structuring and hiding mechanism.
+\item[Effect on original feature:] change to semantics of well-defined feature.
+\item[Difficulty of converting:] Semantic transformation.
+\item[How widely used:] C programs rarely have nest types because they are equivalent to the hoisted version.
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] In C++, the name of a nested class is local to its enclosing class.
+\item[Rationale:] C++ classes have member functions which require that classes establish scopes.
+\item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
+\begin{lstlisting}
+struct Y;                                               §\C{// struct Y and struct X are at the same scope}§
+struct X {
+struct Y { /* ... */ } y;
+};
+\end{lstlisting}
+All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of the enclosing struct could be exported to the scope of the enclosing struct.
+Note: this is a consequence of the difference in scope rules, which is documented in 3.3.
+\item[How widely used:] Seldom.
+\end{description}
+
+\item
+\begin{description}
+\item[Change:] comma expression is disallowed as subscript
+\item[Rationale:] safety issue to prevent subscripting error for multidimensional arrays: ©x[i,j]© instead of ©x[i][j]©, and this syntactic form then taken by \CFA for new style arrays.
+\item[Effect on original feature:] change to semantics of well-defined feature.
+\item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]©
+\item[How widely used:] seldom.
+\end{description}
+\end{enumerate}
+
+
 \section{New Keywords}
 \label{s:NewKeywords}
 
 \begin{quote2}
-\begin{tabular}{ll}
-©catch©                 & ©lvalue©              \\
-©catchResume©   &                               \\
-©choose©                & ©otype©               \\
-                                &                               \\
-©disable©               & ©throw©               \\
-©dtype©                 & ©throwResume© \\
-                                & ©trait©               \\
-©enable©                & ©try©                 \\
-                                &                               \\
-©fallthrough©                                   \\
-©fallthru©                                              \\
-©finally©                                               \\
-©forall©                                                \\
-©ftype©                                                 \\
+\begin{tabular}{lll}
+©catch©                 & ©fallthrough© & ©otype©               \\
+©catchResume©   & ©fallthru©    & ©throw©               \\
+©choose©                & ©finally©             & ©throwResume© \\
+©disable©               & ©forall©              & ©trait©               \\
+©dtype©                 & ©ftype©               & ©try©                 \\
+©enable©                & ©lvalue©              &                               \\
 \end{tabular}
 \end{quote2}
@@ -4395 +4567 @@
 \label{s:StandardHeaders}
 
-C prescribes the following standard header-files:
+C prescribes the following standard header-files~\cite[\S~7.1.2]{C11}:
 \begin{quote2}
 \begin{minipage}{\linewidth}
@@ -4412 +4584 @@
 \end{minipage}
 \end{quote2}
-For the prescribed head-files, \CFA implicit wraps their includes in an ©extern "C"©;
+For the prescribed head-files, \CFA implicitly wraps their includes in an ©extern "C"©;
 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
 All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling.
-
-
-\section{Incompatible}
-
-The following incompatibles exist between \CFA and C, and are similar to Annex C for \CC~\cite{ANSI14:C++}.
-
-\begin{enumerate}
-\item
-\begin{description}
-\item[Change:] add new keywords (see~\VRef{s:NewKeywords}) \\
-New keywords are added to \CFA.
-\item[Rationale:] keywords added to implement new semantics of \CFA.
-\item[Effect on original feature:] change to semantics of well-defined feature. \\
-Any ISO C programs using these keywords as identifiers are invalid \CFA programs.
-\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
-\begin{lstlisting}
-int `otype` = 3;                                // make keyword an identifier
-double `choose` = 3.5;
-\end{lstlisting}
-Programs can be converted automatically by enclosing keyword identifiers in backquotes, and the backquotes can be remove later when the identifier name is changed.
-Clashes in C system libraries (include files) can be handled automatically using preprocessor, ©#include_next© and ©-Ifilename©:
-\begin{lstlisting}
-// include file uses the CFA keyword "otype".
-#if ! defined( otype )                  // nesting ?
-#define otype `otype`
-#define __CFA_BFD_H__
-#endif // ! otype
-
-#include_next <bfd.h>                   // must have internal check for multiple expansion
-
-#if defined( otype ) && defined( __CFA_BFD_H__ )        // reset only if set
-#undef otype
-#undef __CFA_BFD_H__
-#endif // otype && __CFA_BFD_H__
-\end{lstlisting}
-\item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare.
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] type of character literal ©int© to ©char© to allow more intuitive overloading:
-\begin{lstlisting}
-int rtn( int i );
-int rtn( char c );
-rtn( 'x' );                                             // programmer expects 2nd rtn to be called
-\end{lstlisting}
-\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
-In particular, output of ©char© variable now print a character rather than the decimal ASCII value of the character.
-\begin{lstlisting}
-sout | 'x' | " " | (int)'x' | endl;
-x 120
-\end{lstlisting}
-Having to cast ©'x'© to ©char© is non-intuitive.
-\item[Effect on original feature:] change to semantics of well-defined feature that depend on:
-\begin{lstlisting}
-sizeof( 'x' ) == sizeof( int )
-\end{lstlisting}
-no long work the same in \CFA programs.
-\item[Difficulty of converting:] simple
-\item[How widely used:] programs that depend upon ©sizeof( 'x' )© are rare and can be changed to ©sizeof(char)©.
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] make string literals ©const©:
-\begin{lstlisting}
-char * p = "abc";                               // valid in C, deprecated in §\CFA§
-char * q = expr ? "abc" : "de"; // valid in C, invalid in §\CFA§
-\end{lstlisting}
-The type of a string literal is changed from ©[] char© to ©const [] char©.
-Similarly, the type of a wide string literal is changed from ©[] wchar_t© to ©const [] wchar_t©.
-\item[Rationale:] This change is a safety issue:
-\begin{lstlisting}
-char * p = "abc";
-p[0] = 'w';                                             // segment fault or change constant literal
-\end{lstlisting}
-The same problem occurs when passing a string literal to a routine that changes its argument.
-\item[Effect on original feature:] change to semantics of well-defined feature.
-\item[Difficulty of converting:] simple syntactic transformation, because string literals can be converted to ©char *©.
-\item[How widely used:] programs that have a legitimate reason to treat string literals as pointers to potentially modifiable memory are rare.
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
-\begin{lstlisting}
-int i;                                                  // forward definition
-int *j = ®&i®;                                  // forward reference, valid in C, invalid in §\CFA§
-int i = 0;                                              // definition
-\end{lstlisting}
-is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
-This change makes it impossible to define mutually referential file-local static objects, if initializers are restricted to the syntactic forms of C. For example,
-\begin{lstlisting}
-struct X { int i; struct X *next; };
-static struct X a;                              // forward definition
-static struct X b = { 0, ®&a® };        // forward reference, valid in C, invalid in §\CFA§
-static struct X a = { 1, &b };  // definition
-\end{lstlisting}
-\item[Rationale:] avoids having different initialization rules for builtin types and userdefined types.
-\item[Effect on original feature:] change to semantics of well-defined feature.
-\item[Difficulty of converting:] the initializer for one of a set of mutually-referential file-local static objects must invoke a routine call to achieve the initialization.
-\item[How widely used:] seldom
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] have ©struct© introduce a scope for nested types
-In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing
-Example:
-\begin{lstlisting}
-enum ®Colour® { R, G, B, Y, C, M };
-struct Person {
-        enum ®Colour® { R, G, B };      // nested type
-        struct Face {                           // nested type
-                ®Colour® Eyes, Hair;            // type defined outside (1 level)
-        };
-        ß.ß®Colour® shirt;                              // type defined outside (top level)
-        ®Colour® pants;                         // type defined same level
-        Face looks[10];                         // type defined same level
-};
-®Colour® c = R;                                 // type/enum defined same level
-Personß.ß®Colour® pc = Personß.ßR;      // type/enum defined inside
-Personß.ßFace pretty;                           // type defined inside
-\end{lstlisting}
-\item[Rationale:] ©struct© scope is crucial to \CFA as an information structuring and hiding mechanism.
-\item[Effect on original feature:] change to semantics of well-defined feature.
-\item[Difficulty of converting:] Semantic transformation.
-\item[How widely used:] C programs rarely have nest types because they are equivalent to the hoisted version.
-
-\CFA is C \emph{incompatible} on this issue, and provides semantics similar to \Index*[C++]{\CC}.
-Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''.
-Given that nested types in C are equivalent to not using them, \ie they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] In C++, the name of a nested class is local to its enclosing class.
-\item[Rationale:] C++ classes have member functions which require that classes establish scopes.
-\item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
-\begin{lstlisting}
-struct Y; // struct Y and struct X are at the same scope
-struct X {
-struct Y { /* ... */ } y;
-};
-\end{lstlisting}
-All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of the enclosing struct could be exported to the scope of the enclosing struct.
-Note: this is a consequence of the difference in scope rules, which is documented in 3.3.
-\item[How widely used:] Seldom.
-\end{description}
-
-\item
-\begin{description}
-\item[Change:] comma expression is disallowed as subscript
-\item[Rationale:] safety issue to prevent subscripting error for multidimensional arrays: ©x[i,j]© instead of ©x[i][j]©, and this syntactic form then taken by \CFA for new style arrays.
-\item[Effect on original feature:] change to semantics of well-defined feature.
-\item[Difficulty of converting:] semantic transformation of ©x[i,j]© to ©x[(i,j)]©
-\item[How widely used:] seldom.
-\end{description}
-\end{enumerate}
 
 
@@ -4749 +4762 @@
 \subsection{malloc}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 forall( otype T ) T * malloc( void );§\indexc{malloc}§
@@ -4765 +4779 @@
 forall( otype T ) T * memset( T * ptr );                                // remove when default value available
 \end{lstlisting}
-\ 
+
 
 \subsection{ato / strto}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 int ato( const char * ptr );§\indexc{ato}§
@@ -4796 +4811 @@
 long double _Complex strto( const char * sptr, char ** eptr );
 \end{lstlisting}
-\ 
 
 
 \subsection{bsearch / qsort}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 forall( otype T | { int ?<?( T, T ); } )
@@ -4808 +4823 @@
 void qsort( const T * arr, size_t dimension );§\indexc{qsort}§
 \end{lstlisting}
-\ 
 
 
 \subsection{abs}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 char abs( char );§\indexc{abs}§
@@ -4825 +4840 @@
 long double abs( long double _Complex );
 \end{lstlisting}
-\ 
 
 
 \subsection{random}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 void rand48seed( long int s );§\indexc{rand48seed}§
@@ -4843 +4858 @@
 long double _Complex rand48();
 \end{lstlisting}
-\ 
 
 
 \subsection{min / max / clamp / swap}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 forall( otype T | { int ?<?( T, T ); } )
@@ -4861 +4876 @@
 void swap( T * t1, T * t2 );§\indexc{swap}§
 \end{lstlisting}
-\ 
 
 
@@ -4872 +4886 @@
 \subsection{General}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float fabs( float );§\indexc{fabs}§
@@ -4917 +4932 @@
 long double nan( const char * );
 \end{lstlisting}
-\ 
 
 
 \subsection{Exponential}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float exp( float );§\indexc{exp}§
@@ -4974 +4989 @@
 long double logb( long double );
 \end{lstlisting}
-\ 
 
 
 \subsection{Power}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float sqrt( float );§\indexc{sqrt}§
@@ -5002 +5017 @@
 long double _Complex pow( long double _Complex, long double _Complex );
 \end{lstlisting}
-\ 
 
 
 \subsection{Trigonometric}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float sin( float );§\indexc{sin}§
@@ -5058 +5073 @@
 long double atan( long double, long double );
 \end{lstlisting}
-\ 
 
 
 \subsection{Hyperbolic}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float sinh( float );§\indexc{sinh}§
@@ -5106 +5121 @@
 long double _Complex atanh( long double _Complex );
 \end{lstlisting}
-\ 
 
 
 \subsection{Error / Gamma}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float erf( float );§\indexc{erf}§
@@ -5137 +5152 @@
 long double tgamma( long double );
 \end{lstlisting}
-\ 
 
 
 \subsection{Nearest Integer}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float floor( float );§\indexc{floor}§
@@ -5191 +5206 @@
 long long int llround( long double );
 \end{lstlisting}
-\ 
 
 
 \subsection{Manipulation}
 
+\leavevmode
 \begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
 float copysign( float, float );§\indexc{copysign}§
@@ -5232 +5247 @@
 long double scalbln( long double, long int );
 \end{lstlisting}
-\ 
 
 

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Aug  9 08:39:20 2016
-// Update Count     : 169
+// Last Modified On : Sat Aug 13 18:56:58 2016
+// Update Count     : 171
 //
 
@@ -470 +470 @@
 
                 // there may be typedefs chained onto the type
-                if ( o->get_link() ) {
-                        set_link( o->get_link()->clone() );
+                if ( o->get_next() ) {
+                        set_last( o->get_next()->clone() );
                 } // if
         } // if
@@ -757 +757 @@
 DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
         if ( node != 0 ) {
-                set_link( node );
+                set_last( node );
         } // if
         return this;
@@ -794 +794 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast<DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -831 +831 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -848 +848 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 10 11:07:38 2016
-// Update Count     : 486
+// Last Modified On : Thu Aug 11 20:24:36 2016
+// Update Count     : 487
 //
 
@@ -309 +309 @@
 
 //##############################################################################
- 
-// ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
-//      if ( init_ == 0 )
-//              init = 0;
-//      else {
-//              DeclarationNode *decl;
-//              ExpressionNode *exp;
-
-//              if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
-//                      init = new StatementNode( decl );
-//              else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
-//                      init = new StatementNode( StatementNode::Exp, exp );
-//              else
-//                      throw SemanticError("Error in for control expression");
-//      }
-// }
-
-// ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
-//      : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
-// }
-
-// ForCtlExprNode::~ForCtlExprNode() {
-//      delete init;
-//      delete condition;
-//      delete change;
-// }
-
-// Expression *ForCtlExprNode::build() const {
-//      // this shouldn't be used!
-//      assert( false );
-//      return 0;
-// }
-
-// void ForCtlExprNode::print( std::ostream &os, int indent ) const{
-//      os << string( indent,' ' ) << "For Control Expression -- :" << endl;
-
-//      os << string( indent + 2, ' ' ) << "initialization:" << endl;
-//      if ( init != 0 )
-//              init->printList( os, indent + 4 );
-
-//      os << string( indent + 2, ' ' ) << "condition: " << endl;
-//      if ( condition != 0 )
-//              condition->print( os, indent + 4 );
-//      os << string( indent + 2, ' ' ) << "increment: " << endl;
-//      if ( change != 0 )
-//              change->print( os, indent + 4 );
-// }
-
-// void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
-//      assert( false );
-// }
-
-//##############################################################################
 
 Expression *build_typevalue( DeclarationNode *decl ) {

src/Parser/InitializerNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul  4 15:37:15 2016
-// Update Count     : 15
+// Last Modified On : Sat Aug 13 18:55:11 2016
+// Update Count     : 18
 //
 
@@ -25 +25 @@
         : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( aggrp )
-                kids = dynamic_cast< InitializerNode *>( get_link() );
+                kids = dynamic_cast< InitializerNode *>( get_next() );
 
         if ( kids != 0 )
-                set_link( 0 );
+                set_last( 0 );
 }
 
@@ -34 +34 @@
         : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( init != 0 )
-                set_link(init);
+                set_last( init );
 
         if ( aggrp )
-                kids = dynamic_cast< InitializerNode *>( get_link() );
+                kids = dynamic_cast< InitializerNode *>( get_next() );
 
         if ( kids != 0 )
@@ -58 +58 @@
                         while ( curdes != 0) {
                                 curdes->printOneLine(os);
-                                curdes = (ExpressionNode *)(curdes->get_link());
+                                curdes = (ExpressionNode *)(curdes->get_next());
                                 if ( curdes ) os << ", ";
                         } // while
@@ -72 +72 @@
 
         InitializerNode *moreInit;
-        if  ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) )
+        if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
                 moreInit->printOneLine( os );
 }

src/Parser/ParseNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug  7 23:32:47 2016
-// Update Count     : 94
+// Last Modified On : Sat Aug 13 18:55:35 2016
+// Update Count     : 98
 // 
 
@@ -31 +31 @@
         ParseNode *current = this;
 
-        while ( current->get_link() != 0 )
-        current = current->get_link();
-
+        while ( current->get_next() != 0 )
+        current = current->get_next();
         return current;
 }
 
-ParseNode *ParseNode::set_link( ParseNode *next_ ) {
+ParseNode *ParseNode::set_last( ParseNode *next_ ) {
         if ( next_ != 0 ) get_last()->next = next_;
         return this;
@@ -54 +53 @@
 
 ParseNode &ParseNode::operator,( ParseNode &p ) {
-        set_link( &p );
-
+        set_last( &p );
         return *this;
 }

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 11 12:24:11 2016
-// Update Count     : 443
+// Last Modified On : Sun Aug 14 16:29:20 2016
+// Update Count     : 483
 //
 
@@ -45 +45 @@
         virtual ~ParseNode();
 
-        ParseNode *get_link() const { return next; }
+        ParseNode *get_next() const { return next; }
+        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
         ParseNode *get_last();
-        ParseNode *set_link( ParseNode * );
-        void set_next( ParseNode *newlink ) { next = newlink; }
+        ParseNode *set_last( ParseNode * );
 
         virtual ParseNode *clone() const { return 0; };
@@ -92 +92 @@
         ExpressionNode *expr;
         bool aggregate;
-        ExpressionNode *designator; // may be list
+        ExpressionNode *designator;                                                     // may be list
         InitializerNode *kids;
         bool maybeConstructed;
@@ -336 +336 @@
 
         StatementNode();
-        StatementNode( const std::string *name );
-        StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
-        StatementNode( Type t, std::string *target );
         StatementNode( DeclarationNode *decl );
-
         ~StatementNode();
-
-        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
-
-        StatementNode *set_block( StatementNode *b ) { block = b; return this; }
-        StatementNode *get_block() const { return block; }
-
-        void set_control( ExpressionNode *c ) { control = c; }
-        ExpressionNode *get_control() const { return control; }
 
         StatementNode::Type get_type() const { return type; }
@@ -357 +345 @@
 
         void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
-        void setCatchRest( bool newVal ) { isCatchRest = newVal; }
-
-        std::string get_target() const;
-
-        // StatementNode *add_controlexp( ExpressionNode * );
-        StatementNode *append_block( StatementNode * );
+
         virtual StatementNode *append_last_case( StatementNode * );
 
-        void print( std::ostream &os, int indent = 0) const;
+        virtual void print( std::ostream &os, int indent = 0) const {}
         virtual StatementNode *clone() const;
         virtual Statement *build() const;
-  private:
+  public:
         static const char *StType[];
         Type type;
-        ExpressionNode *control;
-        StatementNode *block;
         std::list<std::string> labels;
-        std::string *target;                            // target label for jump statements
         DeclarationNode *decl;
-        bool isCatchRest;
 }; // StatementNode
 
 class StatementNode2 : public StatementNode {
   public:
-        StatementNode2() {}
+        StatementNode2() { stmt = nullptr; }
         StatementNode2( Statement *stmt ) : stmt( stmt ) {}
+        StatementNode2( DeclarationNode *decl );
         virtual ~StatementNode2() {}
 
@@ -392 +372 @@
                 return this;
         }
+        virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
+
         virtual StatementNode *append_last_case( StatementNode * );
-        virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
 
         virtual void print( std::ostream &os, int indent = 0 ) {}
@@ -401 +382 @@
 }; // StatementNode
 
+Statement *build_expr( ExpressionNode *ctl );
+
 struct ForCtl {
         ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
-                init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {}
+                init( new StatementNode2( build_expr( expr ) ) ), condition( condition ), change( change ) {}
         ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
-                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
+                init( new StatementNode2( decl ) ), condition( condition ), change( change ) {}
 
         StatementNode *init;
@@ -412 +395 @@
 };
 
-Statement *build_expr( ExpressionNode *ctl );
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
@@ -423 +405 @@
 Statement *build_return( ExpressionNode *ctl );
 Statement *build_throw( ExpressionNode *ctl );
+Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
+Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
+Statement *build_finally( StatementNode *stmt );
 
 //##############################################################################
@@ -429 +414 @@
   public:
         CompoundStmtNode();
-        CompoundStmtNode( const std::string * );
         CompoundStmtNode( StatementNode * );
         ~CompoundStmtNode();
@@ -445 +429 @@
 class AsmStmtNode : public StatementNode {
   public:
-        AsmStmtNode( Type, bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
+        AsmStmtNode( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
         ~AsmStmtNode();
 
-        void print( std::ostream &os, int indent = 0 ) const;
+        void print( std::ostream &os, int indent = 0 ) const {}
         Statement *build() const;
   private:
@@ -477 +461 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< NodeType *>( cur->get_link() );
+                cur = dynamic_cast< NodeType *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 11 16:19:45 2016
-// Update Count     : 210
+// Last Modified On : Sun Aug 14 13:10:54 2016
+// Update Count     : 288
 //
 
@@ -34 +34 @@
 };
 
-StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
-
-StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
-
-StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) {
+StatementNode::StatementNode() : ParseNode(), labels( 0 ), decl( 0 ) {}
+
+StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), labels( 0 ) {
+        assert( false );
         if ( decl ) {
                 if ( DeclarationNode *agg = decl->extractAggregate() ) {
@@ -46 +45 @@
                         nextStmt->decl = decl;
                         next = nextStmt;
-                        if ( decl->get_link() ) {
-                                next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) );
+                        if ( decl->get_next() ) {
+                                next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) ) );
                                 decl->set_next( 0 );
                         } // if
                 } else {
-                        if ( decl->get_link() ) {
-                                next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) );
+                        if ( decl->get_next() ) {
+                                next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
                                 decl->set_next( 0 );
                         } // if
@@ -60 +59 @@
 }
 
-StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {
-        this->control = ( t == Default ) ? 0 : control;
-}
-
-StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), isCatchRest ( false ) {}
+StatementNode2::StatementNode2( DeclarationNode *decl ) {
+        if ( decl ) {
+                DeclarationNode *agg = decl->extractAggregate();
+                if ( agg ) {
+                        StatementNode *nextStmt = new StatementNode;
+                        nextStmt->type = Decl;
+                        nextStmt->decl = decl;
+                        next = nextStmt;
+                        if ( decl->get_next() ) {
+                                next->set_next( new StatementNode2( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
+                                decl->set_next( 0 );
+                        } // if
+                } else {
+                        if ( decl->get_next() ) {
+                                next = new StatementNode2( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
+                                decl->set_next( 0 );
+                        } // if
+                        agg = decl;
+                } // if
+                stmt = new DeclStmt( noLabels, maybeBuild<Declaration>(agg) );
+        } else {
+                assert( false );
+        } // if
+}
 
 StatementNode::~StatementNode() {
-        delete control;
-        delete block;
-        delete target;
         delete decl;
 }
 
-StatementNode * StatementNode::newCatchStmt( DeclarationNode *d, StatementNode *s, bool catchRestP ) {
-        StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s );
-        ret->addDeclaration( d );
-        ret->setCatchRest( catchRestP );
-
-        return ret;
-}
-
-std::string StatementNode::get_target() const{
-        if ( target )
-                return *target;
-
-        return string("");
-}
-
 StatementNode * StatementNode::clone() const {
-        StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) );
-        if ( target ) {
-                newnode->target = new string( *target );
-        } else {
-                newnode->target = 0;
-        } // if
-        newnode->decl = maybeClone( decl );
-        return newnode;
+        assert( false );
+        return 0;
 }
 
@@ -107 +101 @@
 }
 
-StatementNode *StatementNode::append_block( StatementNode *stmt ) {
-        if ( stmt != 0 ) {
-                if ( block == 0 )
-                        block = stmt;
-                else
-                        block->set_link( stmt );
-        } // if
-        return this;
-}
-
 StatementNode *StatementNode::append_last_case( StatementNode *stmt ) {
         assert( false );
-        if ( stmt != 0 ) {
-                StatementNode *next = ( StatementNode *)get_link();
-                if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default ) )
-                        next->append_last_case( stmt );
-                else
-                        if ( block == 0 )
-                                block = stmt;
-                        else
-                                block->set_link( stmt );
-        } // if
         return this;
 }
@@ -134 +108 @@
 StatementNode *StatementNode2::append_last_case( StatementNode *stmt ) {
         StatementNode *prev = this;
-        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_link() ) {
+        // find end of list and maintain previous pointer
+        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
                 StatementNode2 *node = dynamic_cast<StatementNode2 *>(curr);
                 assert( node );
@@ -140 +115 @@
                 prev = curr;
         } // for
+        // conver from StatementNode list to Statement list
         StatementNode2 *node = dynamic_cast<StatementNode2 *>(prev);
         std::list<Statement *> stmts;
         buildList( stmt, stmts );
-        CaseStmt * caseStmt;
-        caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
+        // splice any new Statements to end of currents Statements
+        CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
 }
 
-void StatementNode::print( std::ostream &os, int indent ) const {
-        if ( ! labels.empty() ) {
-                std::list<std::string>::const_iterator i;
-
-                os << string( indent, ' ' );
-                for ( i = labels.begin(); i != labels.end(); i++ )
-                        os << *i << ":";
-                os << endl;
-        } // if
-
+Statement *StatementNode::build() const {
         switch ( type ) {
           case Decl:
-                decl->print( os, indent );
-                break;
+                return new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) );
+                assert( false );
           case Exp:
-                if ( control ) {
-                        os << string( indent, ' ' );
-                        control->print( os, indent );
-                        os << endl;
-                } else
-                        os << string( indent, ' ' ) << "Null Statement" << endl;
-                break;
-          default:
-                os << string( indent, ' ' ) << StatementNode::StType[type] << endl;
-                if ( type == Catch ) {
-                        if ( decl ) {
-                                os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
-                                decl->print( os, indent + 2 * ParseNode::indent_by );
-                        } else if ( isCatchRest ) {
-                                os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
-                        } else {
-                                ; // should never reach here
-                        } // if
-                } // if
-                if ( control ) {
-                        os << string( indent + ParseNode::indent_by, ' ' ) << "Control: " << endl;
-                        control->printList( os, indent + 2 * ParseNode::indent_by );
-                } // if
-                if ( block ) {
-                        os << string( indent + ParseNode::indent_by, ' ' ) << "Cases: " << endl;
-                        block->printList( os, indent + 2 * ParseNode::indent_by );
-                } // if
-                if ( target ) {
-                        os << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl;
-                } // if
-                break;
-        } // switch
-}
-
-Statement *StatementNode::build() const {
-        std::list<Statement *> branches;
-        std::list<Expression *> exps;
-        std::list<Label> labs;
-
-        if ( ! labels.empty() ) {
-                std::back_insert_iterator< std::list<Label> > lab_it( labs );
-                copy( labels.begin(), labels.end(), lab_it );
-        } // if
-
-        // try {
-        buildList<Statement, StatementNode>( get_block(), branches );
-
-        switch ( type ) {
-          case Decl:
-                return new DeclStmt( labs, maybeBuild< Declaration >( decl ) );
-          case Exp:
-                {
-                        Expression *e = maybeBuild< Expression >( get_control() );
-
-                        if ( e )
-                                return new ExprStmt( labs, e );
-                        else
-                                return new NullStmt( labs );
-                }
-                assert( false );
           case If:
-                // {
-                //      Statement *thenb = 0, *elseb = 0;
-                //      assert( branches.size() >= 1 );
-
-                //      thenb = branches.front();
-                //      branches.pop_front();
-                //      if ( ! branches.empty() ) {
-                //              elseb = branches.front();
-                //              branches.pop_front();
-                //      } // if
-                //      return new IfStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), thenb, elseb );
-                // }
-                assert( false );
           case Switch:
-                // return new SwitchStmt( labs, maybeBuild<Expression>(get_control()), branches );
-                assert( false );
           case Case:
-                //return new CaseStmt( labs, maybeBuild<Expression>(get_control() ), branches );
-                assert( false );
           case Default:
-                //return new CaseStmt( labs, 0, branches, true );
-                assert( false );
           case While:
-                // assert( branches.size() == 1 );
-                // return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front() );
-                assert( false );
           case Do:
-                // assert( branches.size() == 1 );
-                // return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front(), true );
-                assert( false );
           case For:
-                // {
-                //      assert( branches.size() == 1 );
-
-                //      ForCtlExprNode *ctl = dynamic_cast<ForCtlExprNode *>( get_control() );
-                //      assert( ctl != 0 );
-
-                //      std::list<Statement *> init;
-                //      if ( ctl->get_init() != 0 ) {
-                //              buildList( ctl->get_init(), init );
-                //      } // if
-
-                //      Expression *cond = 0;
-                //      if ( ctl->get_condition() != 0 )
-                //              cond = notZeroExpr( maybeBuild<Expression>(ctl->get_condition()) );
-
-                //      Expression *incr = 0;
-                //      if ( ctl->get_change() != 0 )
-                //              incr = maybeBuild<Expression>(ctl->get_change());
-
-                //      return new ForStmt( labs, init, cond, incr, branches.front() );
-                // }
-                assert( false );
           case Goto:
-                // {
-                //      if ( get_target() == "" ) {                                     // computed goto
-                //              assert( get_control() != 0 );
-                //              return new BranchStmt( labs, maybeBuild<Expression>(get_control()), BranchStmt::Goto );
-                //      } // if
-
-                //      return new BranchStmt( labs, get_target(), BranchStmt::Goto );
-                // }
-                assert( false );
           case Break:
-                // return new BranchStmt( labs, get_target(), BranchStmt::Break );
-                assert( false );
           case Continue:
-                // return new BranchStmt( labs, get_target(), BranchStmt::Continue );
-                assert( false );
           case Return:
           case Throw :
-                // buildList( get_control(), exps );
-                // if ( exps.size() ==0 )
-                //      return new ReturnStmt( labs, 0, type == Throw );
-                // if ( exps.size() > 0 )
-                //      return new ReturnStmt( labs, exps.back(), type == Throw );
+          case Try:
+          case Catch:
+          case Finally:
+          case Asm:
+          default:
                 assert( false );
-          case Try:
-                {
-                        assert( branches.size() >= 0 );
-                        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front());
-                        branches.pop_front();
-                        FinallyStmt *finallyBlock = 0;
-                        if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
-                                branches.pop_back();
-                        } // if
-                        return new TryStmt( labs, tryBlock, branches, finallyBlock );
-                }
-          case Catch:
-                {
-                        assert( branches.size() == 1 );
-
-                        return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), isCatchRest );
-                }
-          case Finally:
-                {
-                        assert( branches.size() == 1 );
-                        CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() );
-                        assert( block != 0 );
-
-                        return new FinallyStmt( labs, block );
-                }
-          case Asm:
-                assert( false );
-          default:
-                // shouldn't be here
                 return 0;
         } // switch
@@ -422 +240 @@
 }
 
+Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( catch_stmt, branches );
+        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>(maybeBuild<Statement>(try_stmt));
+        assert( tryBlock );
+        FinallyStmt *finallyBlock = dynamic_cast<FinallyStmt *>(maybeBuild<Statement>(finally_stmt) );
+        return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
+}
+Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
+        assert( branches.size() == 1 );
+        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
+}
+Statement *build_finally( StatementNode *stmt ) {
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
+        assert( branches.size() == 1 );
+        return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
+}
+
 
 CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
-
-CompoundStmtNode::CompoundStmtNode( const string *name_ ) : StatementNode( name_ ), first( 0 ), last( 0 ) {}
 
 CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ) : first( stmt ) {
@@ -441 +278 @@
 void CompoundStmtNode::add_statement( StatementNode *stmt ) {
         if ( stmt != 0 ) {
-                last->set_link( stmt );
-                last = ( StatementNode *)( stmt->get_link());
+                last->set_last( stmt );
+                last = ( StatementNode *)( stmt->get_next());
         } // if
 }
@@ -467 +304 @@
 
 
-AsmStmtNode::AsmStmtNode( Type t, bool voltile, ConstantExpr *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) :
-        StatementNode( t ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ) {
+AsmStmtNode::AsmStmtNode( bool voltile, ConstantExpr *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) :
+        voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ) {
+        type = Asm;
         if ( gotolabels ) {
                 this->gotolabels = gotolabels->get_labels();
@@ -477 +315 @@
 AsmStmtNode::~AsmStmtNode() {
         delete output; delete input; delete clobber;
-}
-
-void AsmStmtNode::print( std::ostream &os, int indent ) const {
-        StatementNode::print( os, indent );                                     // print statement labels
-        os << string( indent + ParseNode::indent_by, ' ' ) << "volatile:" << voltile << endl;
-        if ( instruction ) {
-                os << string( indent + ParseNode::indent_by, ' ' ) << "Instruction:" << endl;
-//              instruction->printList( os, indent + 2 * ParseNode::indent_by );
-        } // if
-        if ( output ) {
-                os << string( indent + ParseNode::indent_by, ' ' ) << "Output:" << endl;
-                output->printList( os, indent + 2 * ParseNode::indent_by );
-        } // if
-        if ( input ) {
-                os << string( indent + ParseNode::indent_by, ' ' ) << "Input:" << endl;
-                input->printList( os, indent + 2 * ParseNode::indent_by );
-        } // if
-        if ( clobber ) {
-                os << string( indent + ParseNode::indent_by, ' ' ) << "Clobber:" << endl;
-//              clobber->printList( os, indent + 2 * ParseNode::indent_by );
-        } // if
-        if ( ! gotolabels.empty() ) {
-                os << string( indent + ParseNode::indent_by, ' ' ) << "Goto Labels:" << endl;
-                os << string( indent + 2 * ParseNode::indent_by, ' ' );
-                for ( std::list<Label>::const_iterator i = gotolabels.begin();; ) {
-                        os << *i;
-                        i++;
-                  if ( i == gotolabels.end() ) break;
-                        os << ", ";
-                }
-                os << endl;
-        } // if
 }
 
@@ -528 +334 @@
 }
 
+// Statement *build_asm( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 ) {
+//      std::list<Label> labs;
+
+//      if ( ! get_labels().empty() ) {
+//              std::back_insert_iterator< std::list<Label> > lab_it( labs );
+//              copy( get_labels().begin(), get_labels().end(), lab_it );
+//      } // if
+
+//      std::list< Expression * > out, in;
+//      std::list< ConstantExpr * > clob;
+//      buildList( output, out );
+//      buildList( input, in );
+//      buildList( clobber, clob );
+//      std::list< Label > gotolabs = gotolabels;
+//      return new AsmStmt( labs, voltile, instruction, out, in, clob, gotolabs );
+// }
+
 // Local Variables: //
 // tab-width: 4 //

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Aug  7 07:51:48 2016
-// Update Count     : 58
+// Last Modified On : Sat Aug 13 18:38:41 2016
+// Update Count     : 59
 //
 
@@ -495 +495 @@
                         decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline, isNoreturn );
                 } // if
-                for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
+                for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
                         if ( cur->get_name() != "" ) {
                                 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
@@ -909 +909 @@
         buildList( enumeration->constants, ret->get_members() );
         std::list< Declaration * >::iterator members = ret->get_members().begin();
-        for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_link() ), ++members ) {
+        for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ), ++members ) {
                 if ( cur->get_enumeratorValue() != NULL ) {
                         ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);

src/Parser/parser.cc

@@ -1020 +1020 @@
 static const yytype_uint16 yyrline[] =
 {
-       0,   299,   299,   305,   314,   315,   316,   320,   321,   322,
-     326,   327,   331,   332,   336,   337,   341,   342,   353,   355,
-     357,   359,   364,   365,   371,   375,   377,   378,   380,   381,
-     383,   385,   387,   396,   397,   403,   404,   408,   409,   413,
-     417,   419,   421,   423,   428,   431,   433,   435,   440,   453,
-     455,   457,   459,   461,   463,   465,   467,   469,   471,   473,
-     480,   481,   487,   488,   489,   490,   494,   495,   497,   502,
-     503,   505,   507,   512,   513,   515,   520,   521,   523,   528,
-     529,   531,   533,   535,   540,   541,   543,   548,   549,   554,
-     555,   560,   561,   566,   567,   572,   573,   578,   579,   582,
-     584,   589,   594,   595,   597,   603,   604,   608,   609,   610,
-     611,   612,   613,   614,   615,   616,   617,   618,   624,   626,
-     628,   630,   635,   636,   641,   642,   648,   649,   655,   656,
-     657,   658,   659,   660,   661,   662,   663,   673,   680,   682,
-     692,   693,   698,   700,   706,   708,   712,   713,   718,   723,
-     726,   728,   730,   740,   742,   753,   754,   756,   761,   763,
-     767,   768,   773,   774,   778,   783,   784,   788,   790,   796,
-     797,   801,   803,   805,   807,   813,   814,   818,   820,   825,
-     827,   829,   834,   836,   841,   843,   847,   850,   854,   857,
-     861,   863,   865,   867,   872,   874,   876,   885,   887,   889,
-     891,   893,   898,   900,   902,   904,   909,   922,   923,   928,
-     930,   935,   939,   941,   943,   945,   947,   953,   954,   960,
-     961,   965,   966,   971,   973,   979,   980,   982,   987,   989,
-     996,   998,  1002,  1003,  1008,  1010,  1014,  1015,  1019,  1021,
-    1025,  1026,  1030,  1031,  1035,  1036,  1051,  1052,  1053,  1054,
-    1055,  1059,  1064,  1071,  1081,  1086,  1091,  1099,  1104,  1109,
-    1114,  1119,  1127,  1149,  1154,  1161,  1163,  1170,  1175,  1180,
-    1191,  1196,  1201,  1206,  1211,  1220,  1225,  1233,  1234,  1235,
-    1236,  1242,  1247,  1255,  1256,  1257,  1258,  1262,  1263,  1264,
-    1265,  1270,  1271,  1280,  1281,  1286,  1287,  1292,  1294,  1296,
-    1298,  1300,  1303,  1302,  1314,  1315,  1317,  1327,  1328,  1333,
-    1337,  1339,  1341,  1343,  1345,  1347,  1349,  1351,  1356,  1358,
-    1360,  1362,  1364,  1366,  1368,  1370,  1372,  1374,  1376,  1378,
-    1380,  1386,  1387,  1389,  1391,  1393,  1398,  1399,  1405,  1406,
-    1408,  1410,  1415,  1417,  1419,  1421,  1426,  1427,  1429,  1431,
-    1436,  1437,  1439,  1444,  1445,  1447,  1449,  1454,  1456,  1458,
-    1463,  1464,  1468,  1470,  1476,  1475,  1479,  1481,  1486,  1488,
-    1494,  1495,  1500,  1501,  1503,  1504,  1513,  1514,  1516,  1518,
-    1523,  1525,  1531,  1532,  1534,  1537,  1540,  1545,  1546,  1551,
-    1556,  1560,  1562,  1568,  1567,  1574,  1576,  1582,  1583,  1591,
-    1592,  1596,  1597,  1598,  1600,  1602,  1609,  1610,  1612,  1614,
-    1619,  1620,  1626,  1627,  1631,  1632,  1637,  1638,  1639,  1641,
-    1649,  1650,  1652,  1655,  1657,  1661,  1662,  1663,  1665,  1667,
-    1671,  1676,  1684,  1685,  1694,  1696,  1701,  1702,  1703,  1707,
-    1708,  1709,  1713,  1714,  1715,  1719,  1720,  1721,  1726,  1727,
-    1728,  1729,  1735,  1736,  1738,  1743,  1744,  1749,  1750,  1751,
-    1752,  1753,  1768,  1769,  1774,  1775,  1781,  1783,  1786,  1788,
-    1790,  1813,  1814,  1816,  1818,  1823,  1824,  1826,  1831,  1836,
-    1837,  1843,  1842,  1846,  1850,  1852,  1854,  1860,  1861,  1866,
-    1871,  1873,  1878,  1880,  1881,  1883,  1888,  1890,  1892,  1897,
-    1899,  1904,  1909,  1917,  1923,  1922,  1936,  1937,  1942,  1943,
-    1947,  1952,  1957,  1965,  1970,  1981,  1982,  1993,  1994,  2000,
-    2001,  2005,  2006,  2007,  2010,  2009,  2020,  2029,  2035,  2041,
-    2050,  2056,  2062,  2068,  2074,  2082,  2088,  2096,  2102,  2111,
-    2112,  2113,  2117,  2121,  2123,  2128,  2129,  2133,  2134,  2139,
-    2145,  2146,  2149,  2151,  2152,  2156,  2157,  2158,  2159,  2193,
-    2195,  2196,  2198,  2203,  2208,  2213,  2215,  2217,  2222,  2224,
-    2226,  2228,  2233,  2235,  2244,  2246,  2247,  2252,  2254,  2256,
-    2261,  2263,  2265,  2270,  2272,  2274,  2283,  2284,  2285,  2289,
-    2291,  2293,  2298,  2300,  2302,  2307,  2309,  2311,  2326,  2328,
-    2329,  2331,  2336,  2337,  2342,  2344,  2346,  2351,  2353,  2355,
-    2357,  2362,  2364,  2366,  2376,  2378,  2379,  2381,  2386,  2388,
-    2390,  2395,  2397,  2399,  2401,  2406,  2408,  2410,  2441,  2443,
-    2444,  2446,  2451,  2456,  2464,  2466,  2468,  2473,  2475,  2480,
-    2482,  2496,  2497,  2499,  2504,  2506,  2508,  2510,  2512,  2517,
-    2518,  2520,  2522,  2527,  2529,  2531,  2537,  2539,  2541,  2545,
-    2547,  2549,  2551,  2565,  2566,  2568,  2573,  2575,  2577,  2579,
-    2581,  2586,  2587,  2589,  2591,  2596,  2598,  2600,  2606,  2607,
-    2609,  2618,  2621,  2623,  2626,  2628,  2630,  2643,  2644,  2646,
-    2651,  2653,  2655,  2657,  2659,  2664,  2665,  2667,  2669,  2674,
-    2676,  2684,  2685,  2686,  2691,  2692,  2696,  2698,  2700,  2702,
-    2704,  2706,  2713,  2715,  2717,  2719,  2721,  2723,  2725,  2727,
-    2729,  2731,  2736,  2738,  2740,  2745,  2771,  2772,  2774,  2778,
-    2779,  2783,  2785,  2787,  2789,  2791,  2793,  2800,  2802,  2804,
-    2806,  2808,  2810,  2815,  2820,  2822,  2824,  2842,  2844,  2849,
-    2850
+       0,   298,   298,   304,   313,   314,   315,   319,   320,   321,
+     325,   326,   330,   331,   335,   336,   340,   341,   352,   354,
+     356,   358,   363,   364,   370,   374,   376,   377,   379,   380,
+     382,   384,   386,   395,   396,   402,   403,   407,   408,   412,
+     416,   418,   420,   422,   427,   430,   432,   434,   439,   452,
+     454,   456,   458,   460,   462,   464,   466,   468,   470,   472,
+     479,   480,   486,   487,   488,   489,   493,   494,   496,   501,
+     502,   504,   506,   511,   512,   514,   519,   520,   522,   527,
+     528,   530,   532,   534,   539,   540,   542,   547,   548,   553,
+     554,   559,   560,   565,   566,   571,   572,   577,   578,   581,
+     583,   588,   593,   594,   596,   602,   603,   607,   608,   609,
+     610,   611,   612,   613,   614,   615,   616,   617,   623,   625,
+     627,   629,   634,   635,   640,   641,   647,   648,   654,   655,
+     656,   657,   658,   659,   660,   661,   662,   672,   679,   681,
+     691,   692,   697,   699,   705,   707,   711,   712,   717,   722,
+     725,   727,   729,   739,   741,   752,   753,   755,   759,   761,
+     765,   766,   771,   772,   776,   781,   782,   786,   788,   794,
+     795,   799,   801,   803,   805,   811,   812,   816,   818,   823,
+     825,   827,   832,   834,   839,   841,   845,   848,   852,   855,
+     859,   861,   863,   865,   870,   872,   874,   879,   881,   883,
+     885,   887,   892,   894,   896,   898,   903,   915,   916,   921,
+     923,   928,   932,   934,   936,   938,   940,   946,   947,   953,
+     954,   958,   959,   964,   966,   972,   973,   975,   980,   982,
+     989,   991,   995,   996,  1001,  1003,  1007,  1008,  1012,  1014,
+    1018,  1019,  1023,  1024,  1028,  1029,  1044,  1045,  1046,  1047,
+    1048,  1052,  1057,  1064,  1074,  1079,  1084,  1092,  1097,  1102,
+    1107,  1112,  1120,  1142,  1147,  1154,  1156,  1163,  1168,  1173,
+    1184,  1189,  1194,  1199,  1204,  1213,  1218,  1226,  1227,  1228,
+    1229,  1235,  1240,  1248,  1249,  1250,  1251,  1255,  1256,  1257,
+    1258,  1263,  1264,  1273,  1274,  1279,  1280,  1285,  1287,  1289,
+    1291,  1293,  1296,  1295,  1307,  1308,  1310,  1320,  1321,  1326,
+    1330,  1332,  1334,  1336,  1338,  1340,  1342,  1344,  1349,  1351,
+    1353,  1355,  1357,  1359,  1361,  1363,  1365,  1367,  1369,  1371,
+    1373,  1379,  1380,  1382,  1384,  1386,  1391,  1392,  1398,  1399,
+    1401,  1403,  1408,  1410,  1412,  1414,  1419,  1420,  1422,  1424,
+    1429,  1430,  1432,  1437,  1438,  1440,  1442,  1447,  1449,  1451,
+    1456,  1457,  1461,  1463,  1469,  1468,  1472,  1474,  1479,  1481,
+    1487,  1488,  1493,  1494,  1496,  1497,  1506,  1507,  1509,  1511,
+    1516,  1518,  1524,  1525,  1527,  1530,  1533,  1538,  1539,  1544,
+    1549,  1553,  1555,  1561,  1560,  1567,  1569,  1575,  1576,  1584,
+    1585,  1589,  1590,  1591,  1593,  1595,  1602,  1603,  1605,  1607,
+    1612,  1613,  1619,  1620,  1624,  1625,  1630,  1631,  1632,  1634,
+    1642,  1643,  1645,  1648,  1650,  1654,  1655,  1656,  1658,  1660,
+    1664,  1669,  1677,  1678,  1687,  1689,  1694,  1695,  1696,  1700,
+    1701,  1702,  1706,  1707,  1708,  1712,  1713,  1714,  1719,  1720,
+    1721,  1722,  1728,  1729,  1731,  1736,  1737,  1742,  1743,  1744,
+    1745,  1746,  1761,  1762,  1767,  1768,  1774,  1776,  1779,  1781,
+    1783,  1806,  1807,  1809,  1811,  1816,  1817,  1819,  1824,  1829,
+    1830,  1836,  1835,  1839,  1843,  1845,  1847,  1853,  1854,  1859,
+    1864,  1866,  1871,  1873,  1874,  1876,  1881,  1883,  1885,  1890,
+    1892,  1897,  1902,  1910,  1916,  1915,  1929,  1930,  1935,  1936,
+    1940,  1945,  1950,  1958,  1963,  1974,  1975,  1986,  1987,  1993,
+    1994,  1998,  1999,  2000,  2003,  2002,  2013,  2022,  2028,  2034,
+    2043,  2049,  2055,  2061,  2067,  2075,  2081,  2089,  2095,  2104,
+    2105,  2106,  2110,  2114,  2116,  2121,  2122,  2126,  2127,  2132,
+    2138,  2139,  2142,  2144,  2145,  2149,  2150,  2151,  2152,  2186,
+    2188,  2189,  2191,  2196,  2201,  2206,  2208,  2210,  2215,  2217,
+    2219,  2221,  2226,  2228,  2237,  2239,  2240,  2245,  2247,  2249,
+    2254,  2256,  2258,  2263,  2265,  2267,  2276,  2277,  2278,  2282,
+    2284,  2286,  2291,  2293,  2295,  2300,  2302,  2304,  2319,  2321,
+    2322,  2324,  2329,  2330,  2335,  2337,  2339,  2344,  2346,  2348,
+    2350,  2355,  2357,  2359,  2369,  2371,  2372,  2374,  2379,  2381,
+    2383,  2388,  2390,  2392,  2394,  2399,  2401,  2403,  2434,  2436,
+    2437,  2439,  2444,  2449,  2457,  2459,  2461,  2466,  2468,  2473,
+    2475,  2489,  2490,  2492,  2497,  2499,  2501,  2503,  2505,  2510,
+    2511,  2513,  2515,  2520,  2522,  2524,  2530,  2532,  2534,  2538,
+    2540,  2542,  2544,  2558,  2559,  2561,  2566,  2568,  2570,  2572,
+    2574,  2579,  2580,  2582,  2584,  2589,  2591,  2593,  2599,  2600,
+    2602,  2611,  2614,  2616,  2619,  2621,  2623,  2636,  2637,  2639,
+    2644,  2646,  2648,  2650,  2652,  2657,  2658,  2660,  2662,  2667,
+    2669,  2677,  2678,  2679,  2684,  2685,  2689,  2691,  2693,  2695,
+    2697,  2699,  2706,  2708,  2710,  2712,  2714,  2716,  2718,  2720,
+    2722,  2724,  2729,  2731,  2733,  2738,  2764,  2765,  2767,  2771,
+    2772,  2776,  2778,  2780,  2782,  2784,  2786,  2793,  2795,  2797,
+    2799,  2801,  2803,  2808,  2813,  2815,  2817,  2835,  2837,  2842,
+    2843
 };
 #endif
@@ -4960 +4960 @@
 
 /* Line 1806 of yacc.c  */
-#line 299 "parser.yy"
+#line 298 "parser.yy"
     {
                         typedefTable.enterScope();
@@ -4969 +4969 @@
 
 /* Line 1806 of yacc.c  */
-#line 305 "parser.yy"
+#line 304 "parser.yy"
     {
                         typedefTable.leaveScope();
@@ -4978 +4978 @@
 
 /* Line 1806 of yacc.c  */
+#line 313 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
+    break;
+
+  case 5:
+
+/* Line 1806 of yacc.c  */
 #line 314 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
-    break;
-
-  case 5:
+    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
+    break;
+
+  case 6:
 
 /* Line 1806 of yacc.c  */
 #line 315 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
-    break;
-
-  case 6:
-
-/* Line 1806 of yacc.c  */
-#line 316 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4999 +4999 @@
 
 /* Line 1806 of yacc.c  */
-#line 341 "parser.yy"
+#line 340 "parser.yy"
     { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].tok) ); }
     break;
@@ -5006 +5006 @@
 
 /* Line 1806 of yacc.c  */
-#line 343 "parser.yy"
+#line 342 "parser.yy"
     {
                         appendStr( (yyvsp[(1) - (2)].constant)->get_constant()->get_value(), (yyvsp[(2) - (2)].tok) );
@@ -5017 +5017 @@
 
 /* Line 1806 of yacc.c  */
-#line 354 "parser.yy"
+#line 353 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5024 +5024 @@
 
 /* Line 1806 of yacc.c  */
-#line 356 "parser.yy"
+#line 355 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5031 +5031 @@
 
 /* Line 1806 of yacc.c  */
-#line 358 "parser.yy"
+#line 357 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (3)].en); }
     break;
@@ -5038 +5038 @@
 
 /* Line 1806 of yacc.c  */
-#line 360 "parser.yy"
+#line 359 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
     break;
@@ -5045 +5045 @@
 
 /* Line 1806 of yacc.c  */
-#line 370 "parser.yy"
+#line 369 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     break;
@@ -5052 +5052 @@
 
 /* Line 1806 of yacc.c  */
-#line 372 "parser.yy"
+#line 371 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5059 +5059 @@
 
 /* Line 1806 of yacc.c  */
-#line 376 "parser.yy"
+#line 375 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
@@ -5066 +5066 @@
 
 /* Line 1806 of yacc.c  */
-#line 379 "parser.yy"
+#line 378 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
@@ -5073 +5073 @@
 
 /* Line 1806 of yacc.c  */
-#line 382 "parser.yy"
+#line 381 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5080 +5080 @@
 
 /* Line 1806 of yacc.c  */
-#line 384 "parser.yy"
+#line 383 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5087 +5087 @@
 
 /* Line 1806 of yacc.c  */
-#line 386 "parser.yy"
+#line 385 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
     break;
@@ -5094 +5094 @@
 
 /* Line 1806 of yacc.c  */
-#line 388 "parser.yy"
+#line 387 "parser.yy"
     {
                         Token fn;
                         fn.str = new std::string( "?{}" ); // location undefined
-                        (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) ) );
+                        (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) );
                 }
     break;
@@ -5105 +5105 @@
 
 /* Line 1806 of yacc.c  */
-#line 398 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
+#line 397 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
 
@@ -5112 +5112 @@
 
 /* Line 1806 of yacc.c  */
-#line 403 "parser.yy"
+#line 402 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5119 +5119 @@
 
 /* Line 1806 of yacc.c  */
-#line 409 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
+#line 408 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
 
@@ -5126 +5126 @@
 
 /* Line 1806 of yacc.c  */
-#line 414 "parser.yy"
+#line 413 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5133 +5133 @@
 
 /* Line 1806 of yacc.c  */
-#line 418 "parser.yy"
+#line 417 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
@@ -5140 +5140 @@
 
 /* Line 1806 of yacc.c  */
-#line 420 "parser.yy"
+#line 419 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
@@ -5147 +5147 @@
 
 /* Line 1806 of yacc.c  */
-#line 422 "parser.yy"
+#line 421 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
@@ -5154 +5154 @@
 
 /* Line 1806 of yacc.c  */
-#line 424 "parser.yy"
+#line 423 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
@@ -5161 +5161 @@
 
 /* Line 1806 of yacc.c  */
-#line 432 "parser.yy"
+#line 431 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5168 +5168 @@
 
 /* Line 1806 of yacc.c  */
-#line 434 "parser.yy"
+#line 433 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
@@ -5175 +5175 @@
 
 /* Line 1806 of yacc.c  */
-#line 436 "parser.yy"
+#line 435 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
     break;
@@ -5182 +5182 @@
 
 /* Line 1806 of yacc.c  */
-#line 441 "parser.yy"
+#line 440 "parser.yy"
     {
                         switch ( (yyvsp[(1) - (2)].op) ) {
@@ -5200 +5200 @@
 
 /* Line 1806 of yacc.c  */
-#line 454 "parser.yy"
+#line 453 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5207 +5207 @@
 
 /* Line 1806 of yacc.c  */
-#line 456 "parser.yy"
+#line 455 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5214 +5214 @@
 
 /* Line 1806 of yacc.c  */
-#line 458 "parser.yy"
+#line 457 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5221 +5221 @@
 
 /* Line 1806 of yacc.c  */
-#line 460 "parser.yy"
+#line 459 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5228 +5228 @@
 
 /* Line 1806 of yacc.c  */
-#line 462 "parser.yy"
+#line 461 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5235 +5235 @@
 
 /* Line 1806 of yacc.c  */
-#line 464 "parser.yy"
+#line 463 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5242 +5242 @@
 
 /* Line 1806 of yacc.c  */
-#line 466 "parser.yy"
+#line 465 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5249 +5249 @@
 
 /* Line 1806 of yacc.c  */
-#line 468 "parser.yy"
+#line 467 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
     break;
@@ -5256 +5256 @@
 
 /* Line 1806 of yacc.c  */
-#line 470 "parser.yy"
+#line 469 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
     break;
@@ -5263 +5263 @@
 
 /* Line 1806 of yacc.c  */
-#line 472 "parser.yy"
+#line 471 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5270 +5270 @@
 
 /* Line 1806 of yacc.c  */
-#line 474 "parser.yy"
+#line 473 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5277 +5277 @@
 
 /* Line 1806 of yacc.c  */
+#line 479 "parser.yy"
+    { (yyval.op) = OperKinds::PointTo; }
+    break;
+
+  case 61:
+
+/* Line 1806 of yacc.c  */
 #line 480 "parser.yy"
-    { (yyval.op) = OperKinds::PointTo; }
-    break;
-
-  case 61:
-
-/* Line 1806 of yacc.c  */
-#line 481 "parser.yy"
     { (yyval.op) = OperKinds::AddressOf; }
     break;
@@ -5291 +5291 @@
 
 /* Line 1806 of yacc.c  */
+#line 486 "parser.yy"
+    { (yyval.op) = OperKinds::UnPlus; }
+    break;
+
+  case 63:
+
+/* Line 1806 of yacc.c  */
 #line 487 "parser.yy"
-    { (yyval.op) = OperKinds::UnPlus; }
-    break;
-
-  case 63:
+    { (yyval.op) = OperKinds::UnMinus; }
+    break;
+
+  case 64:
 
 /* Line 1806 of yacc.c  */
 #line 488 "parser.yy"
-    { (yyval.op) = OperKinds::UnMinus; }
-    break;
-
-  case 64:
+    { (yyval.op) = OperKinds::Neg; }
+    break;
+
+  case 65:
 
 /* Line 1806 of yacc.c  */
 #line 489 "parser.yy"
-    { (yyval.op) = OperKinds::Neg; }
-    break;
-
-  case 65:
-
-/* Line 1806 of yacc.c  */
-#line 490 "parser.yy"
     { (yyval.op) = OperKinds::BitNeg; }
     break;
@@ -5319 +5319 @@
 
 /* Line 1806 of yacc.c  */
-#line 496 "parser.yy"
+#line 495 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5326 +5326 @@
 
 /* Line 1806 of yacc.c  */
-#line 498 "parser.yy"
+#line 497 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5333 +5333 @@
 
 /* Line 1806 of yacc.c  */
-#line 504 "parser.yy"
+#line 503 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5340 +5340 @@
 
 /* Line 1806 of yacc.c  */
-#line 506 "parser.yy"
+#line 505 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5347 +5347 @@
 
 /* Line 1806 of yacc.c  */
-#line 508 "parser.yy"
+#line 507 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5354 +5354 @@
 
 /* Line 1806 of yacc.c  */
-#line 514 "parser.yy"
+#line 513 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5361 +5361 @@
 
 /* Line 1806 of yacc.c  */
-#line 516 "parser.yy"
+#line 515 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5368 +5368 @@
 
 /* Line 1806 of yacc.c  */
-#line 522 "parser.yy"
+#line 521 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5375 +5375 @@
 
 /* Line 1806 of yacc.c  */
-#line 524 "parser.yy"
+#line 523 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5382 +5382 @@
 
 /* Line 1806 of yacc.c  */
-#line 530 "parser.yy"
+#line 529 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5389 +5389 @@
 
 /* Line 1806 of yacc.c  */
-#line 532 "parser.yy"
+#line 531 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5396 +5396 @@
 
 /* Line 1806 of yacc.c  */
-#line 534 "parser.yy"
+#line 533 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5403 +5403 @@
 
 /* Line 1806 of yacc.c  */
-#line 536 "parser.yy"
+#line 535 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5410 +5410 @@
 
 /* Line 1806 of yacc.c  */
-#line 542 "parser.yy"
+#line 541 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5417 +5417 @@
 
 /* Line 1806 of yacc.c  */
-#line 544 "parser.yy"
+#line 543 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5424 +5424 @@
 
 /* Line 1806 of yacc.c  */
-#line 550 "parser.yy"
+#line 549 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5431 +5431 @@
 
 /* Line 1806 of yacc.c  */
-#line 556 "parser.yy"
+#line 555 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5438 +5438 @@
 
 /* Line 1806 of yacc.c  */
-#line 562 "parser.yy"
+#line 561 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5445 +5445 @@
 
 /* Line 1806 of yacc.c  */
-#line 568 "parser.yy"
+#line 567 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     break;
@@ -5452 +5452 @@
 
 /* Line 1806 of yacc.c  */
-#line 574 "parser.yy"
+#line 573 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     break;
@@ -5459 +5459 @@
 
 /* Line 1806 of yacc.c  */
-#line 580 "parser.yy"
+#line 579 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
@@ -5466 +5466 @@
 
 /* Line 1806 of yacc.c  */
-#line 583 "parser.yy"
+#line 582 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5473 +5473 @@
 
 /* Line 1806 of yacc.c  */
-#line 585 "parser.yy"
+#line 584 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
@@ -5480 +5480 @@
 
 /* Line 1806 of yacc.c  */
-#line 596 "parser.yy"
+#line 595 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5487 +5487 @@
 
 /* Line 1806 of yacc.c  */
-#line 598 "parser.yy"
+#line 597 "parser.yy"
     { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5494 +5494 @@
 
 /* Line 1806 of yacc.c  */
-#line 603 "parser.yy"
+#line 602 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -5501 +5501 @@
 
 /* Line 1806 of yacc.c  */
+#line 607 "parser.yy"
+    { (yyval.op) = OperKinds::Assign; }
+    break;
+
+  case 108:
+
+/* Line 1806 of yacc.c  */
 #line 608 "parser.yy"
-    { (yyval.op) = OperKinds::Assign; }
-    break;
-
-  case 108:
+    { (yyval.op) = OperKinds::MulAssn; }
+    break;
+
+  case 109:
 
 /* Line 1806 of yacc.c  */
 #line 609 "parser.yy"
-    { (yyval.op) = OperKinds::MulAssn; }
-    break;
-
-  case 109:
+    { (yyval.op) = OperKinds::DivAssn; }
+    break;
+
+  case 110:
 
 /* Line 1806 of yacc.c  */
 #line 610 "parser.yy"
-    { (yyval.op) = OperKinds::DivAssn; }
-    break;
-
-  case 110:
+    { (yyval.op) = OperKinds::ModAssn; }
+    break;
+
+  case 111:
 
 /* Line 1806 of yacc.c  */
 #line 611 "parser.yy"
-    { (yyval.op) = OperKinds::ModAssn; }
-    break;
-
-  case 111:
+    { (yyval.op) = OperKinds::PlusAssn; }
+    break;
+
+  case 112:
 
 /* Line 1806 of yacc.c  */
 #line 612 "parser.yy"
-    { (yyval.op) = OperKinds::PlusAssn; }
-    break;
-
-  case 112:
+    { (yyval.op) = OperKinds::MinusAssn; }
+    break;
+
+  case 113:
 
 /* Line 1806 of yacc.c  */
 #line 613 "parser.yy"
-    { (yyval.op) = OperKinds::MinusAssn; }
-    break;
-
-  case 113:
+    { (yyval.op) = OperKinds::LSAssn; }
+    break;
+
+  case 114:
 
 /* Line 1806 of yacc.c  */
 #line 614 "parser.yy"
-    { (yyval.op) = OperKinds::LSAssn; }
-    break;
-
-  case 114:
+    { (yyval.op) = OperKinds::RSAssn; }
+    break;
+
+  case 115:
 
 /* Line 1806 of yacc.c  */
 #line 615 "parser.yy"
-    { (yyval.op) = OperKinds::RSAssn; }
-    break;
-
-  case 115:
+    { (yyval.op) = OperKinds::AndAssn; }
+    break;
+
+  case 116:
 
 /* Line 1806 of yacc.c  */
 #line 616 "parser.yy"
-    { (yyval.op) = OperKinds::AndAssn; }
-    break;
-
-  case 116:
+    { (yyval.op) = OperKinds::ERAssn; }
+    break;
+
+  case 117:
 
 /* Line 1806 of yacc.c  */
 #line 617 "parser.yy"
-    { (yyval.op) = OperKinds::ERAssn; }
-    break;
-
-  case 117:
-
-/* Line 1806 of yacc.c  */
-#line 618 "parser.yy"
     { (yyval.op) = OperKinds::OrAssn; }
     break;
@@ -5578 +5578 @@
 
 /* Line 1806 of yacc.c  */
-#line 625 "parser.yy"
+#line 624 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple() ); }
     break;
@@ -5585 +5585 @@
 
 /* Line 1806 of yacc.c  */
-#line 627 "parser.yy"
+#line 626 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
     break;
@@ -5592 +5592 @@
 
 /* Line 1806 of yacc.c  */
-#line 629 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
+#line 628 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
     break;
 
@@ -5599 +5599 @@
 
 /* Line 1806 of yacc.c  */
-#line 631 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
+#line 630 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
     break;
 
@@ -5606 +5606 @@
 
 /* Line 1806 of yacc.c  */
-#line 637 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
+#line 636 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
 
@@ -5613 +5613 @@
 
 /* Line 1806 of yacc.c  */
-#line 643 "parser.yy"
+#line 642 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5620 +5620 @@
 
 /* Line 1806 of yacc.c  */
-#line 648 "parser.yy"
+#line 647 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5627 +5627 @@
 
 /* Line 1806 of yacc.c  */
-#line 657 "parser.yy"
+#line 656 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
     break;
@@ -5634 +5634 @@
 
 /* Line 1806 of yacc.c  */
-#line 664 "parser.yy"
+#line 663 "parser.yy"
     {
                         Token fn;
                         fn.str = new std::string( "^?{}" ); // location undefined
-                        (yyval.sn) = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ) ) ) );
+                        (yyval.sn) = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) );
                 }
     break;
@@ -5645 +5645 @@
 
 /* Line 1806 of yacc.c  */
-#line 674 "parser.yy"
+#line 673 "parser.yy"
     {
                         (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
@@ -5654 +5654 @@
 
 /* Line 1806 of yacc.c  */
-#line 681 "parser.yy"
+#line 680 "parser.yy"
     { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
     break;
@@ -5661 +5661 @@
 
 /* Line 1806 of yacc.c  */
-#line 688 "parser.yy"
+#line 687 "parser.yy"
     { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
     break;
@@ -5668 +5668 @@
 
 /* Line 1806 of yacc.c  */
-#line 694 "parser.yy"
-    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
+#line 693 "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;
 
@@ -5675 +5675 @@
 
 /* Line 1806 of yacc.c  */
-#line 699 "parser.yy"
-    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
+#line 698 "parser.yy"
+    { (yyval.sn) = new StatementNode2( (yyvsp[(1) - (1)].decl) ); }
     break;
 
@@ -5682 +5682 @@
 
 /* Line 1806 of yacc.c  */
-#line 701 "parser.yy"
+#line 700 "parser.yy"
     {   // mark all fields in list
-                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
+                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_next() )
                                 iter->set_extension( true );
-                        (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) );
+                        (yyval.sn) = new StatementNode2( (yyvsp[(2) - (2)].decl) );
                 }
     break;
@@ -5693 +5693 @@
 
 /* Line 1806 of yacc.c  */
-#line 707 "parser.yy"
-    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
+#line 706 "parser.yy"
+    { (yyval.sn) = new StatementNode2( (yyvsp[(1) - (1)].decl) ); }
     break;
 
@@ -5700 +5700 @@
 
 /* Line 1806 of yacc.c  */
-#line 714 "parser.yy"
-    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
+#line 713 "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;
 
@@ -5707 +5707 @@
 
 /* Line 1806 of yacc.c  */
-#line 719 "parser.yy"
+#line 718 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_expr( (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5714 +5714 @@
 
 /* Line 1806 of yacc.c  */
-#line 725 "parser.yy"
+#line 724 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
     break;
@@ -5721 +5721 @@
 
 /* Line 1806 of yacc.c  */
-#line 727 "parser.yy"
+#line 726 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
     break;
@@ -5728 +5728 @@
 
 /* Line 1806 of yacc.c  */
-#line 729 "parser.yy"
+#line 728 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5735 +5735 @@
 
 /* Line 1806 of yacc.c  */
-#line 731 "parser.yy"
+#line 730 "parser.yy"
     {
                         StatementNode *sw = new StatementNode2( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
@@ -5743 +5743 @@
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
-                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_link( sw )) ) : sw;
+                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) : sw;
                 }
     break;
@@ -5750 +5750 @@
 
 /* Line 1806 of yacc.c  */
-#line 741 "parser.yy"
+#line 740 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5757 +5757 @@
 
 /* Line 1806 of yacc.c  */
-#line 743 "parser.yy"
+#line 742 "parser.yy"
     {
                         StatementNode *sw = new StatementNode2( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
-                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_link( sw )) ) : sw;
+                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) : sw;
                 }
     break;
@@ -5767 +5767 @@
 
 /* Line 1806 of yacc.c  */
-#line 753 "parser.yy"
+#line 752 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5774 +5774 @@
 
 /* Line 1806 of yacc.c  */
-#line 755 "parser.yy"
+#line 754 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5781 +5781 @@
 
 /* Line 1806 of yacc.c  */
+#line 759 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_case( (yyvsp[(1) - (1)].en) ) ); }
+    break;
+
+  case 159:
+
+/* Line 1806 of yacc.c  */
 #line 761 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_case( (yyvsp[(1) - (1)].en) ) ); }
-    break;
-
-  case 159:
-
-/* Line 1806 of yacc.c  */
-#line 763 "parser.yy"
-    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode2( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
+    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode2( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
     break;
 
@@ -5795 +5795 @@
 
 /* Line 1806 of yacc.c  */
-#line 767 "parser.yy"
+#line 765 "parser.yy"
     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     break;
@@ -5802 +5802 @@
 
 /* Line 1806 of yacc.c  */
-#line 768 "parser.yy"
+#line 766 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_default() ); }
     break;
@@ -5809 +5809 @@
 
 /* Line 1806 of yacc.c  */
-#line 774 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
+#line 772 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
     break;
 
@@ -5816 +5816 @@
 
 /* Line 1806 of yacc.c  */
-#line 778 "parser.yy"
+#line 776 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
     break;
@@ -5823 +5823 @@
 
 /* Line 1806 of yacc.c  */
-#line 783 "parser.yy"
+#line 781 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5830 +5830 @@
 
 /* Line 1806 of yacc.c  */
+#line 787 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
+    break;
+
+  case 168:
+
+/* Line 1806 of yacc.c  */
 #line 789 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
-    break;
-
-  case 168:
-
-/* Line 1806 of yacc.c  */
-#line 791 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     break;
 
@@ -5844 +5844 @@
 
 /* Line 1806 of yacc.c  */
-#line 796 "parser.yy"
+#line 794 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5851 +5851 @@
 
 /* Line 1806 of yacc.c  */
+#line 800 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
+    break;
+
+  case 172:
+
+/* Line 1806 of yacc.c  */
 #line 802 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
-    break;
-
-  case 172:
+    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
+    break;
+
+  case 173:
 
 /* Line 1806 of yacc.c  */
 #line 804 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
-    break;
-
-  case 173:
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
+    break;
+
+  case 174:
 
 /* Line 1806 of yacc.c  */
 #line 806 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
-    break;
-
-  case 174:
-
-/* Line 1806 of yacc.c  */
-#line 808 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
     break;
 
@@ -5879 +5879 @@
 
 /* Line 1806 of yacc.c  */
-#line 813 "parser.yy"
+#line 811 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Break ) ); }
     break;
 
   case 177:
+
+/* Line 1806 of yacc.c  */
+#line 817 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+
+  case 178:
 
 /* Line 1806 of yacc.c  */
@@ -5890 +5897 @@
     break;
 
-  case 178:
-
-/* Line 1806 of yacc.c  */
-#line 821 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
   case 179:
 
 /* Line 1806 of yacc.c  */
+#line 824 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+
+  case 180:
+
+/* Line 1806 of yacc.c  */
 #line 826 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
-    break;
-
-  case 180:
+    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
+    break;
+
+  case 181:
 
 /* Line 1806 of yacc.c  */
 #line 828 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
-    break;
-
-  case 181:
-
-/* Line 1806 of yacc.c  */
-#line 830 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
     break;
@@ -5921 +5921 @@
 
 /* Line 1806 of yacc.c  */
+#line 833 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
+    break;
+
+  case 183:
+
+/* Line 1806 of yacc.c  */
 #line 835 "parser.yy"
-    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
-    break;
-
-  case 183:
-
-/* Line 1806 of yacc.c  */
-#line 837 "parser.yy"
     { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     break;
@@ -5935 +5935 @@
 
 /* Line 1806 of yacc.c  */
-#line 842 "parser.yy"
+#line 840 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
     break;
@@ -5942 +5942 @@
 
 /* Line 1806 of yacc.c  */
-#line 846 "parser.yy"
+#line 844 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5949 +5949 @@
 
 /* Line 1806 of yacc.c  */
-#line 849 "parser.yy"
+#line 847 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Continue ) ); }
     break;
@@ -5956 +5956 @@
 
 /* Line 1806 of yacc.c  */
-#line 853 "parser.yy"
+#line 851 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); delete (yyvsp[(2) - (3)].tok); }
     break;
@@ -5963 +5963 @@
 
 /* Line 1806 of yacc.c  */
-#line 856 "parser.yy"
+#line 854 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Break ) ); }
     break;
@@ -5970 +5970 @@
 
 /* Line 1806 of yacc.c  */
+#line 858 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); delete (yyvsp[(2) - (3)].tok); }
+    break;
+
+  case 190:
+
+/* Line 1806 of yacc.c  */
 #line 860 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); delete (yyvsp[(2) - (3)].tok); }
-    break;
-
-  case 190:
+    { (yyval.sn) = new StatementNode2( build_return( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+
+  case 191:
 
 /* Line 1806 of yacc.c  */
 #line 862 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_return( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-
-  case 191:
+    { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+
+  case 192:
 
 /* Line 1806 of yacc.c  */
@@ -5988 +5995 @@
     break;
 
-  case 192:
+  case 193:
 
 /* Line 1806 of yacc.c  */
 #line 866 "parser.yy"
-    { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-
-  case 193:
-
-/* Line 1806 of yacc.c  */
-#line 868 "parser.yy"
     { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (5)].en) ) ); }
     break;
@@ -6005 +6005 @@
 
 /* Line 1806 of yacc.c  */
+#line 871 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
+    break;
+
+  case 195:
+
+/* Line 1806 of yacc.c  */
 #line 873 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
-    break;
-
-  case 195:
+    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
+    break;
+
+  case 196:
 
 /* Line 1806 of yacc.c  */
 #line 875 "parser.yy"
-    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
-    break;
-
-  case 196:
-
-/* Line 1806 of yacc.c  */
-#line 877 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
+    break;
+
+  case 198:
+
+/* Line 1806 of yacc.c  */
+#line 882 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+
+  case 199:
+
+/* Line 1806 of yacc.c  */
+#line 884 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode2( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
+    break;
+
+  case 200:
+
+/* Line 1806 of yacc.c  */
+#line 886 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+
+  case 201:
+
+/* Line 1806 of yacc.c  */
+#line 888 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode2( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
+    break;
+
+  case 202:
+
+/* Line 1806 of yacc.c  */
+#line 893 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+
+  case 203:
+
+/* Line 1806 of yacc.c  */
+#line 895 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode2( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
+    break;
+
+  case 204:
+
+/* Line 1806 of yacc.c  */
+#line 897 "parser.yy"
+    { (yyval.sn) = new StatementNode2( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+
+  case 205:
+
+/* Line 1806 of yacc.c  */
+#line 899 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode2( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
+    break;
+
+  case 206:
+
+/* Line 1806 of yacc.c  */
+#line 904 "parser.yy"
     {
-                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
-                        (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (4)].sn),*(yyvsp[(3) - (4)].pn) ))));
+                        (yyval.sn) = new StatementNode2( build_finally( (yyvsp[(2) - (2)].sn) ) );
                 }
     break;
 
-  case 198:
-
-/* Line 1806 of yacc.c  */
-#line 888 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
-    break;
-
-  case 199:
-
-/* Line 1806 of yacc.c  */
-#line 890 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
-    break;
-
-  case 200:
-
-/* Line 1806 of yacc.c  */
-#line 892 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
-    break;
-
-  case 201:
-
-/* Line 1806 of yacc.c  */
-#line 894 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
-    break;
-
-  case 202:
-
-/* Line 1806 of yacc.c  */
-#line 899 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
-    break;
-
-  case 203:
-
-/* Line 1806 of yacc.c  */
-#line 901 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
-    break;
-
-  case 204:
-
-/* Line 1806 of yacc.c  */
-#line 903 "parser.yy"
-    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
-    break;
-
-  case 205:
-
-/* Line 1806 of yacc.c  */
-#line 905 "parser.yy"
-    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
-    break;
-
-  case 206:
-
-/* Line 1806 of yacc.c  */
-#line 910 "parser.yy"
-    {
-                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
-                        std::cout << "Just created a finally node" << std::endl;
-                }
-    break;
-
   case 208:
 
 /* Line 1806 of yacc.c  */
-#line 924 "parser.yy"
+#line 917 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6105 +6101 @@
 
 /* Line 1806 of yacc.c  */
-#line 929 "parser.yy"
+#line 922 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6112 +6108 @@
 
 /* Line 1806 of yacc.c  */
-#line 931 "parser.yy"
+#line 924 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6122 +6118 @@
 
 /* Line 1806 of yacc.c  */
-#line 940 "parser.yy"
-    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
+#line 933 "parser.yy"
+    { (yyval.sn) = new AsmStmtNode( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
     break;
 
@@ -6129 +6125 @@
 
 /* Line 1806 of yacc.c  */
-#line 942 "parser.yy"
-    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
+#line 935 "parser.yy"
+    { (yyval.sn) = new AsmStmtNode( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
     break;
 
@@ -6136 +6132 @@
 
 /* Line 1806 of yacc.c  */
-#line 944 "parser.yy"
-    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
+#line 937 "parser.yy"
+    { (yyval.sn) = new AsmStmtNode( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
     break;
 
@@ -6143 +6139 @@
 
 /* Line 1806 of yacc.c  */
+#line 939 "parser.yy"
+    { (yyval.sn) = new AsmStmtNode( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ); }
+    break;
+
+  case 216:
+
+/* Line 1806 of yacc.c  */
+#line 941 "parser.yy"
+    { (yyval.sn) = new AsmStmtNode( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ); }
+    break;
+
+  case 217:
+
+/* Line 1806 of yacc.c  */
 #line 946 "parser.yy"
-    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ); }
-    break;
-
-  case 216:
+    { (yyval.flag) = false; }
+    break;
+
+  case 218:
 
 /* Line 1806 of yacc.c  */
 #line 948 "parser.yy"
-    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ); }
-    break;
-
-  case 217:
+    { (yyval.flag) = true; }
+    break;
+
+  case 219:
 
 /* Line 1806 of yacc.c  */
 #line 953 "parser.yy"
-    { (yyval.flag) = false; }
-    break;
-
-  case 218:
-
-/* Line 1806 of yacc.c  */
-#line 955 "parser.yy"
-    { (yyval.flag) = true; }
-    break;
-
-  case 219:
+    { (yyval.en) = 0; }
+    break;
+
+  case 222:
 
 /* Line 1806 of yacc.c  */
 #line 960 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
+    break;
+
+  case 223:
+
+/* Line 1806 of yacc.c  */
+#line 965 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_asm( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
+    break;
+
+  case 224:
+
+/* Line 1806 of yacc.c  */
+#line 967 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_asm( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
+    break;
+
+  case 225:
+
+/* Line 1806 of yacc.c  */
+#line 972 "parser.yy"
     { (yyval.en) = 0; }
     break;
 
-  case 222:
-
-/* Line 1806 of yacc.c  */
-#line 967 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 223:
-
-/* Line 1806 of yacc.c  */
-#line 972 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_asm( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
-    break;
-
-  case 224:
+  case 226:
 
 /* Line 1806 of yacc.c  */
 #line 974 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_asm( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
-    break;
-
-  case 225:
-
-/* Line 1806 of yacc.c  */
-#line 979 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 226:
+    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
+    break;
+
+  case 227:
+
+/* Line 1806 of yacc.c  */
+#line 976 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
+    break;
+
+  case 228:
 
 /* Line 1806 of yacc.c  */
 #line 981 "parser.yy"
-    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
-    break;
-
-  case 227:
+    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
+    break;
+
+  case 229:
 
 /* Line 1806 of yacc.c  */
 #line 983 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
-    break;
-
-  case 228:
-
-/* Line 1806 of yacc.c  */
-#line 988 "parser.yy"
-    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 229:
+    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
+    break;
+
+  case 230:
 
 /* Line 1806 of yacc.c  */
 #line 990 "parser.yy"
-    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
-    break;
-
-  case 230:
+    { (yyval.decl) = 0; }
+    break;
+
+  case 233:
 
 /* Line 1806 of yacc.c  */
 #line 997 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 234:
+
+/* Line 1806 of yacc.c  */
+#line 1002 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 
-  case 233:
-
-/* Line 1806 of yacc.c  */
-#line 1004 "parser.yy"
+  case 237:
+
+/* Line 1806 of yacc.c  */
+#line 1009 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
 
-  case 234:
-
-/* Line 1806 of yacc.c  */
-#line 1009 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 237:
-
-/* Line 1806 of yacc.c  */
-#line 1016 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
   case 242:
 
 /* Line 1806 of yacc.c  */
-#line 1030 "parser.yy"
+#line 1023 "parser.yy"
     {}
     break;
@@ -6269 +6265 @@
 
 /* Line 1806 of yacc.c  */
-#line 1031 "parser.yy"
+#line 1024 "parser.yy"
     {}
     break;
@@ -6276 +6272 @@
 
 /* Line 1806 of yacc.c  */
-#line 1060 "parser.yy"
+#line 1053 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6286 +6282 @@
 
 /* Line 1806 of yacc.c  */
-#line 1067 "parser.yy"
+#line 1060 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6296 +6292 @@
 
 /* Line 1806 of yacc.c  */
-#line 1072 "parser.yy"
+#line 1065 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
@@ -6306 +6302 @@
 
 /* Line 1806 of yacc.c  */
-#line 1082 "parser.yy"
+#line 1075 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6316 +6312 @@
 
 /* Line 1806 of yacc.c  */
-#line 1087 "parser.yy"
+#line 1080 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6326 +6322 @@
 
 /* Line 1806 of yacc.c  */
-#line 1092 "parser.yy"
+#line 1085 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
@@ -6336 +6332 @@
 
 /* Line 1806 of yacc.c  */
-#line 1100 "parser.yy"
+#line 1093 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6346 +6342 @@
 
 /* Line 1806 of yacc.c  */
-#line 1105 "parser.yy"
+#line 1098 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6356 +6352 @@
 
 /* Line 1806 of yacc.c  */
-#line 1110 "parser.yy"
+#line 1103 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6366 +6362 @@
 
 /* Line 1806 of yacc.c  */
-#line 1115 "parser.yy"
+#line 1108 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6376 +6372 @@
 
 /* Line 1806 of yacc.c  */
-#line 1120 "parser.yy"
+#line 1113 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -6386 +6382 @@
 
 /* Line 1806 of yacc.c  */
-#line 1128 "parser.yy"
+#line 1121 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
@@ -6395 +6391 @@
 
 /* Line 1806 of yacc.c  */
-#line 1151 "parser.yy"
+#line 1144 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6404 +6400 @@
 
 /* Line 1806 of yacc.c  */
-#line 1155 "parser.yy"
+#line 1148 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6413 +6409 @@
 
 /* Line 1806 of yacc.c  */
-#line 1162 "parser.yy"
+#line 1155 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -6420 +6416 @@
 
 /* Line 1806 of yacc.c  */
-#line 1166 "parser.yy"
+#line 1159 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
     break;
@@ -6427 +6423 @@
 
 /* Line 1806 of yacc.c  */
-#line 1171 "parser.yy"
+#line 1164 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6437 +6433 @@
 
 /* Line 1806 of yacc.c  */
-#line 1176 "parser.yy"
+#line 1169 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6447 +6443 @@
 
 /* Line 1806 of yacc.c  */
-#line 1181 "parser.yy"
+#line 1174 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
@@ -6457 +6453 @@
 
 /* Line 1806 of yacc.c  */
-#line 1192 "parser.yy"
+#line 1185 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6467 +6463 @@
 
 /* Line 1806 of yacc.c  */
-#line 1197 "parser.yy"
+#line 1190 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6477 +6473 @@
 
 /* Line 1806 of yacc.c  */
-#line 1202 "parser.yy"
+#line 1195 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6487 +6483 @@
 
 /* Line 1806 of yacc.c  */
-#line 1207 "parser.yy"
+#line 1200 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6497 +6493 @@
 
 /* Line 1806 of yacc.c  */
-#line 1212 "parser.yy"
+#line 1205 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6507 +6503 @@
 
 /* Line 1806 of yacc.c  */
-#line 1221 "parser.yy"
+#line 1214 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
@@ -6517 +6513 @@
 
 /* Line 1806 of yacc.c  */
-#line 1226 "parser.yy"
+#line 1219 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
@@ -6527 +6523 @@
 
 /* Line 1806 of yacc.c  */
-#line 1243 "parser.yy"
+#line 1236 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6537 +6533 @@
 
 /* Line 1806 of yacc.c  */
-#line 1248 "parser.yy"
+#line 1241 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6547 +6543 @@
 
 /* Line 1806 of yacc.c  */
-#line 1270 "parser.yy"
+#line 1263 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6554 +6550 @@
 
 /* Line 1806 of yacc.c  */
-#line 1282 "parser.yy"
+#line 1275 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6561 +6557 @@
 
 /* Line 1806 of yacc.c  */
-#line 1293 "parser.yy"
+#line 1286 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     break;
@@ -6568 +6564 @@
 
 /* Line 1806 of yacc.c  */
-#line 1295 "parser.yy"
+#line 1288 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     break;
@@ -6575 +6571 @@
 
 /* Line 1806 of yacc.c  */
-#line 1297 "parser.yy"
+#line 1290 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     break;
@@ -6582 +6578 @@
 
 /* Line 1806 of yacc.c  */
-#line 1299 "parser.yy"
+#line 1292 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     break;
@@ -6589 +6585 @@
 
 /* Line 1806 of yacc.c  */
-#line 1301 "parser.yy"
+#line 1294 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     break;
@@ -6596 +6592 @@
 
 /* Line 1806 of yacc.c  */
-#line 1303 "parser.yy"
+#line 1296 "parser.yy"
     {
                         typedefTable.enterScope();
@@ -6605 +6601 @@
 
 /* Line 1806 of yacc.c  */
-#line 1307 "parser.yy"
+#line 1300 "parser.yy"
     {
                         typedefTable.leaveScope();
@@ -6615 +6611 @@
 
 /* Line 1806 of yacc.c  */
-#line 1316 "parser.yy"
+#line 1309 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6622 +6618 @@
 
 /* Line 1806 of yacc.c  */
-#line 1318 "parser.yy"
+#line 1311 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6629 +6625 @@
 
 /* Line 1806 of yacc.c  */
-#line 1329 "parser.yy"
+#line 1322 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6636 +6632 @@
 
 /* Line 1806 of yacc.c  */
-#line 1338 "parser.yy"
+#line 1331 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     break;
@@ -6643 +6639 @@
 
 /* Line 1806 of yacc.c  */
-#line 1340 "parser.yy"
+#line 1333 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     break;
@@ -6650 +6646 @@
 
 /* Line 1806 of yacc.c  */
-#line 1342 "parser.yy"
+#line 1335 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     break;
@@ -6657 +6653 @@
 
 /* Line 1806 of yacc.c  */
-#line 1344 "parser.yy"
+#line 1337 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     break;
@@ -6664 +6660 @@
 
 /* Line 1806 of yacc.c  */
-#line 1346 "parser.yy"
+#line 1339 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
     break;
@@ -6671 +6667 @@
 
 /* Line 1806 of yacc.c  */
-#line 1348 "parser.yy"
+#line 1341 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     break;
@@ -6678 +6674 @@
 
 /* Line 1806 of yacc.c  */
+#line 1343 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
+    break;
+
+  case 317:
+
+/* Line 1806 of yacc.c  */
+#line 1345 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+    break;
+
+  case 318:
+
+/* Line 1806 of yacc.c  */
 #line 1350 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
-    break;
-
-  case 317:
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+    break;
+
+  case 319:
 
 /* Line 1806 of yacc.c  */
 #line 1352 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
-    break;
-
-  case 318:
-
-/* Line 1806 of yacc.c  */
-#line 1357 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
-    break;
-
-  case 319:
-
-/* Line 1806 of yacc.c  */
-#line 1359 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     break;
@@ -6706 +6702 @@
 
 /* Line 1806 of yacc.c  */
-#line 1361 "parser.yy"
+#line 1354 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     break;
@@ -6713 +6709 @@
 
 /* Line 1806 of yacc.c  */
-#line 1363 "parser.yy"
+#line 1356 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     break;
@@ -6720 +6716 @@
 
 /* Line 1806 of yacc.c  */
-#line 1365 "parser.yy"
+#line 1358 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     break;
@@ -6727 +6723 @@
 
 /* Line 1806 of yacc.c  */
-#line 1367 "parser.yy"
+#line 1360 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     break;
@@ -6734 +6730 @@
 
 /* Line 1806 of yacc.c  */
-#line 1369 "parser.yy"
+#line 1362 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     break;
@@ -6741 +6737 @@
 
 /* Line 1806 of yacc.c  */
-#line 1371 "parser.yy"
+#line 1364 "parser.yy"
     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     break;
@@ -6748 +6744 @@
 
 /* Line 1806 of yacc.c  */
-#line 1373 "parser.yy"
+#line 1366 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     break;
@@ -6755 +6751 @@
 
 /* Line 1806 of yacc.c  */
-#line 1375 "parser.yy"
+#line 1368 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     break;
@@ -6762 +6758 @@
 
 /* Line 1806 of yacc.c  */
-#line 1377 "parser.yy"
+#line 1370 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     break;
@@ -6769 +6765 @@
 
 /* Line 1806 of yacc.c  */
-#line 1379 "parser.yy"
+#line 1372 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
     break;
@@ -6776 +6772 @@
 
 /* Line 1806 of yacc.c  */
+#line 1374 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
+    break;
+
+  case 332:
+
+/* Line 1806 of yacc.c  */
 #line 1381 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
-    break;
-
-  case 332:
-
-/* Line 1806 of yacc.c  */
-#line 1388 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6790 +6786 @@
 
 /* Line 1806 of yacc.c  */
-#line 1390 "parser.yy"
+#line 1383 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6797 +6793 @@
 
 /* Line 1806 of yacc.c  */
-#line 1392 "parser.yy"
+#line 1385 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6804 +6800 @@
 
 /* Line 1806 of yacc.c  */
-#line 1394 "parser.yy"
+#line 1387 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -6811 +6807 @@
 
 /* Line 1806 of yacc.c  */
+#line 1393 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 339:
+
+/* Line 1806 of yacc.c  */
 #line 1400 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 339:
-
-/* Line 1806 of yacc.c  */
-#line 1407 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6825 +6821 @@
 
 /* Line 1806 of yacc.c  */
+#line 1402 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 341:
+
+/* Line 1806 of yacc.c  */
+#line 1404 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 342:
+
+/* Line 1806 of yacc.c  */
 #line 1409 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
+    break;
+
+  case 343:
+
+/* Line 1806 of yacc.c  */
+#line 1411 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
+    break;
+
+  case 344:
+
+/* Line 1806 of yacc.c  */
+#line 1413 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
+    break;
+
+  case 345:
+
+/* Line 1806 of yacc.c  */
+#line 1415 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+
+  case 347:
+
+/* Line 1806 of yacc.c  */
+#line 1421 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 348:
+
+/* Line 1806 of yacc.c  */
+#line 1423 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 341:
-
-/* Line 1806 of yacc.c  */
-#line 1411 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 342:
-
-/* Line 1806 of yacc.c  */
-#line 1416 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
-    break;
-
-  case 343:
-
-/* Line 1806 of yacc.c  */
-#line 1418 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 344:
-
-/* Line 1806 of yacc.c  */
-#line 1420 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 345:
-
-/* Line 1806 of yacc.c  */
-#line 1422 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 347:
-
-/* Line 1806 of yacc.c  */
-#line 1428 "parser.yy"
+  case 349:
+
+/* Line 1806 of yacc.c  */
+#line 1425 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 351:
+
+/* Line 1806 of yacc.c  */
+#line 1431 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 348:
-
-/* Line 1806 of yacc.c  */
-#line 1430 "parser.yy"
+  case 352:
+
+/* Line 1806 of yacc.c  */
+#line 1433 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 349:
-
-/* Line 1806 of yacc.c  */
-#line 1432 "parser.yy"
+  case 354:
+
+/* Line 1806 of yacc.c  */
+#line 1439 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 355:
+
+/* Line 1806 of yacc.c  */
+#line 1441 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 356:
+
+/* Line 1806 of yacc.c  */
+#line 1443 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
 
-  case 351:
-
-/* Line 1806 of yacc.c  */
-#line 1438 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 352:
-
-/* Line 1806 of yacc.c  */
-#line 1440 "parser.yy"
+  case 357:
+
+/* Line 1806 of yacc.c  */
+#line 1448 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
+    break;
+
+  case 358:
+
+/* Line 1806 of yacc.c  */
+#line 1450 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 359:
+
+/* Line 1806 of yacc.c  */
+#line 1452 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 354:
-
-/* Line 1806 of yacc.c  */
-#line 1446 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 355:
-
-/* Line 1806 of yacc.c  */
-#line 1448 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 356:
-
-/* Line 1806 of yacc.c  */
-#line 1450 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 357:
-
-/* Line 1806 of yacc.c  */
-#line 1455 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 358:
-
-/* Line 1806 of yacc.c  */
-#line 1457 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 359:
-
-/* Line 1806 of yacc.c  */
-#line 1459 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
   case 362:
 
 /* Line 1806 of yacc.c  */
-#line 1469 "parser.yy"
+#line 1462 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
     break;
@@ -6951 +6947 @@
 
 /* Line 1806 of yacc.c  */
-#line 1471 "parser.yy"
+#line 1464 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
@@ -6961 +6957 @@
 
 /* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
+#line 1469 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     break;
@@ -6968 +6964 @@
 
 /* Line 1806 of yacc.c  */
-#line 1478 "parser.yy"
+#line 1471 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
     break;
@@ -6975 +6971 @@
 
 /* Line 1806 of yacc.c  */
+#line 1473 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
+    break;
+
+  case 367:
+
+/* Line 1806 of yacc.c  */
+#line 1475 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
+    break;
+
+  case 368:
+
+/* Line 1806 of yacc.c  */
 #line 1480 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
-    break;
-
-  case 367:
+    { (yyval.aggKey) = DeclarationNode::Struct; }
+    break;
+
+  case 369:
 
 /* Line 1806 of yacc.c  */
 #line 1482 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 368:
+    { (yyval.aggKey) = DeclarationNode::Union; }
+    break;
+
+  case 370:
 
 /* Line 1806 of yacc.c  */
 #line 1487 "parser.yy"
-    { (yyval.aggKey) = DeclarationNode::Struct; }
-    break;
-
-  case 369:
+    { (yyval.decl) = 0; }
+    break;
+
+  case 371:
 
 /* Line 1806 of yacc.c  */
 #line 1489 "parser.yy"
-    { (yyval.aggKey) = DeclarationNode::Union; }
-    break;
-
-  case 370:
-
-/* Line 1806 of yacc.c  */
-#line 1494 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 371:
-
-/* Line 1806 of yacc.c  */
-#line 1496 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
@@ -7017 +7013 @@
 
 /* Line 1806 of yacc.c  */
-#line 1502 "parser.yy"
+#line 1495 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
     break;
@@ -7024 +7020 @@
 
 /* Line 1806 of yacc.c  */
-#line 1505 "parser.yy"
+#line 1498 "parser.yy"
     {   // mark all fields in list
-                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
+                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_next() )
                                 iter->set_extension( true );
                         (yyval.decl) = (yyvsp[(2) - (3)].decl);
@@ -7035 +7031 @@
 
 /* Line 1806 of yacc.c  */
-#line 1515 "parser.yy"
+#line 1508 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     break;
@@ -7042 +7038 @@
 
 /* Line 1806 of yacc.c  */
+#line 1510 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
+    break;
+
+  case 379:
+
+/* Line 1806 of yacc.c  */
+#line 1512 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
+    break;
+
+  case 380:
+
+/* Line 1806 of yacc.c  */
 #line 1517 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
-    break;
-
-  case 379:
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 381:
 
 /* Line 1806 of yacc.c  */
 #line 1519 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
-    break;
-
-  case 380:
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
+    break;
+
+  case 382:
 
 /* Line 1806 of yacc.c  */
 #line 1524 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 381:
+    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
+    break;
+
+  case 383:
 
 /* Line 1806 of yacc.c  */
 #line 1526 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
-    break;
-
-  case 382:
-
-/* Line 1806 of yacc.c  */
-#line 1531 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
-    break;
-
-  case 383:
-
-/* Line 1806 of yacc.c  */
-#line 1533 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     break;
@@ -7084 +7080 @@
 
 /* Line 1806 of yacc.c  */
-#line 1536 "parser.yy"
+#line 1529 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7091 +7087 @@
 
 /* Line 1806 of yacc.c  */
-#line 1539 "parser.yy"
+#line 1532 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7098 +7094 @@
 
 /* Line 1806 of yacc.c  */
+#line 1538 "parser.yy"
+    { (yyval.en) = 0; }
+    break;
+
+  case 388:
+
+/* Line 1806 of yacc.c  */
+#line 1540 "parser.yy"
+    { (yyval.en) = (yyvsp[(1) - (1)].en); }
+    break;
+
+  case 389:
+
+/* Line 1806 of yacc.c  */
 #line 1545 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 388:
-
-/* Line 1806 of yacc.c  */
-#line 1547 "parser.yy"
-    { (yyval.en) = (yyvsp[(1) - (1)].en); }
-    break;
-
-  case 389:
-
-/* Line 1806 of yacc.c  */
-#line 1552 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7119 +7115 @@
 
 /* Line 1806 of yacc.c  */
-#line 1561 "parser.yy"
+#line 1554 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -7126 +7122 @@
 
 /* Line 1806 of yacc.c  */
-#line 1563 "parser.yy"
+#line 1556 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
@@ -7136 +7132 @@
 
 /* Line 1806 of yacc.c  */
+#line 1561 "parser.yy"
+    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
+    break;
+
+  case 394:
+
+/* Line 1806 of yacc.c  */
+#line 1563 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
+    break;
+
+  case 395:
+
+/* Line 1806 of yacc.c  */
 #line 1568 "parser.yy"
-    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
-    break;
-
-  case 394:
+    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
+    break;
+
+  case 396:
 
 /* Line 1806 of yacc.c  */
 #line 1570 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
-    break;
-
-  case 395:
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
+    break;
+
+  case 397:
 
 /* Line 1806 of yacc.c  */
 #line 1575 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 396:
+    { (yyval.en) = 0; }
+    break;
+
+  case 398:
 
 /* Line 1806 of yacc.c  */
 #line 1577 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
-    break;
-
-  case 397:
-
-/* Line 1806 of yacc.c  */
-#line 1582 "parser.yy"
-    { (yyval.en) = 0; }
-    break;
-
-  case 398:
+    { (yyval.en) = (yyvsp[(2) - (2)].en); }
+    break;
+
+  case 399:
 
 /* Line 1806 of yacc.c  */
 #line 1584 "parser.yy"
-    { (yyval.en) = (yyvsp[(2) - (2)].en); }
-    break;
-
-  case 399:
-
-/* Line 1806 of yacc.c  */
-#line 1591 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7185 +7181 @@
 
 /* Line 1806 of yacc.c  */
-#line 1599 "parser.yy"
+#line 1592 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7192 +7188 @@
 
 /* Line 1806 of yacc.c  */
-#line 1601 "parser.yy"
+#line 1594 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7199 +7195 @@
 
 /* Line 1806 of yacc.c  */
-#line 1603 "parser.yy"
+#line 1596 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7206 +7202 @@
 
 /* Line 1806 of yacc.c  */
-#line 1611 "parser.yy"
+#line 1604 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7213 +7209 @@
 
 /* Line 1806 of yacc.c  */
-#line 1613 "parser.yy"
+#line 1606 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7220 +7216 @@
 
 /* Line 1806 of yacc.c  */
-#line 1615 "parser.yy"
+#line 1608 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     break;
@@ -7227 +7223 @@
 
 /* Line 1806 of yacc.c  */
-#line 1621 "parser.yy"
+#line 1614 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7234 +7230 @@
 
 /* Line 1806 of yacc.c  */
+#line 1619 "parser.yy"
+    { (yyval.decl) = 0; }
+    break;
+
+  case 415:
+
+/* Line 1806 of yacc.c  */
 #line 1626 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 415:
+    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
+    break;
+
+  case 418:
 
 /* Line 1806 of yacc.c  */
 #line 1633 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
-    break;
-
-  case 418:
-
-/* Line 1806 of yacc.c  */
-#line 1640 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7255 +7251 @@
 
 /* Line 1806 of yacc.c  */
-#line 1642 "parser.yy"
+#line 1635 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7262 +7258 @@
 
 /* Line 1806 of yacc.c  */
-#line 1651 "parser.yy"
+#line 1644 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7269 +7265 @@
 
 /* Line 1806 of yacc.c  */
-#line 1654 "parser.yy"
+#line 1647 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7276 +7272 @@
 
 /* Line 1806 of yacc.c  */
-#line 1656 "parser.yy"
+#line 1649 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
     break;
@@ -7283 +7279 @@
 
 /* Line 1806 of yacc.c  */
-#line 1666 "parser.yy"
+#line 1659 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7290 +7286 @@
 
 /* Line 1806 of yacc.c  */
-#line 1672 "parser.yy"
+#line 1665 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7300 +7296 @@
 
 /* Line 1806 of yacc.c  */
-#line 1677 "parser.yy"
+#line 1670 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7310 +7306 @@
 
 /* Line 1806 of yacc.c  */
-#line 1686 "parser.yy"
+#line 1679 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7317 +7313 @@
 
 /* Line 1806 of yacc.c  */
-#line 1695 "parser.yy"
+#line 1688 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7324 +7320 @@
 
 /* Line 1806 of yacc.c  */
-#line 1697 "parser.yy"
+#line 1690 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -7331 +7327 @@
 
 /* Line 1806 of yacc.c  */
-#line 1722 "parser.yy"
+#line 1715 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7338 +7334 @@
 
 /* Line 1806 of yacc.c  */
+#line 1723 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 452:
+
+/* Line 1806 of yacc.c  */
+#line 1728 "parser.yy"
+    { (yyval.in) = 0; }
+    break;
+
+  case 453:
+
+/* Line 1806 of yacc.c  */
 #line 1730 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 452:
-
-/* Line 1806 of yacc.c  */
-#line 1735 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in); }
+    break;
+
+  case 454:
+
+/* Line 1806 of yacc.c  */
+#line 1732 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
+    break;
+
+  case 455:
+
+/* Line 1806 of yacc.c  */
+#line 1736 "parser.yy"
+    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
+    break;
+
+  case 456:
+
+/* Line 1806 of yacc.c  */
+#line 1737 "parser.yy"
+    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
+    break;
+
+  case 457:
+
+/* Line 1806 of yacc.c  */
+#line 1742 "parser.yy"
     { (yyval.in) = 0; }
     break;
 
-  case 453:
-
-/* Line 1806 of yacc.c  */
-#line 1737 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in); }
-    break;
-
-  case 454:
-
-/* Line 1806 of yacc.c  */
-#line 1739 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
-    break;
-
-  case 455:
-
-/* Line 1806 of yacc.c  */
-#line 1743 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 456:
+  case 459:
 
 /* Line 1806 of yacc.c  */
 #line 1744 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
-    break;
-
-  case 457:
-
-/* Line 1806 of yacc.c  */
-#line 1749 "parser.yy"
-    { (yyval.in) = 0; }
-    break;
-
-  case 459:
-
-/* Line 1806 of yacc.c  */
-#line 1751 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     break;
@@ -7394 +7390 @@
 
 /* Line 1806 of yacc.c  */
-#line 1752 "parser.yy"
-    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
+#line 1745 "parser.yy"
+    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     break;
 
@@ -7401 +7397 @@
 
 /* Line 1806 of yacc.c  */
-#line 1754 "parser.yy"
-    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
+#line 1747 "parser.yy"
+    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     break;
 
@@ -7408 +7404 @@
 
 /* Line 1806 of yacc.c  */
-#line 1770 "parser.yy"
+#line 1763 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     break;
@@ -7415 +7411 @@
 
 /* Line 1806 of yacc.c  */
-#line 1776 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) ) ); }
+#line 1769 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
     break;
 
@@ -7422 +7418 @@
 
 /* Line 1806 of yacc.c  */
+#line 1775 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
+    break;
+
+  case 467:
+
+/* Line 1806 of yacc.c  */
+#line 1778 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+
+  case 468:
+
+/* Line 1806 of yacc.c  */
+#line 1780 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+
+  case 469:
+
+/* Line 1806 of yacc.c  */
 #line 1782 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
-    break;
-
-  case 467:
-
-/* Line 1806 of yacc.c  */
-#line 1785 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 468:
-
-/* Line 1806 of yacc.c  */
-#line 1787 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 469:
-
-/* Line 1806 of yacc.c  */
-#line 1789 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
     break;
@@ -7450 +7446 @@
 
 /* Line 1806 of yacc.c  */
-#line 1791 "parser.yy"
+#line 1784 "parser.yy"
     { (yyval.en) = (yyvsp[(4) - (6)].en); }
     break;
@@ -7457 +7453 @@
 
 /* Line 1806 of yacc.c  */
-#line 1815 "parser.yy"
+#line 1808 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7464 +7460 @@
 
 /* Line 1806 of yacc.c  */
-#line 1817 "parser.yy"
+#line 1810 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7471 +7467 @@
 
 /* Line 1806 of yacc.c  */
-#line 1819 "parser.yy"
+#line 1812 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7478 +7474 @@
 
 /* Line 1806 of yacc.c  */
+#line 1818 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 477:
+
+/* Line 1806 of yacc.c  */
+#line 1820 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 478:
+
+/* Line 1806 of yacc.c  */
 #line 1825 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 477:
-
-/* Line 1806 of yacc.c  */
-#line 1827 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 478:
-
-/* Line 1806 of yacc.c  */
-#line 1832 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     break;
@@ -7499 +7495 @@
 
 /* Line 1806 of yacc.c  */
+#line 1831 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
+    break;
+
+  case 481:
+
+/* Line 1806 of yacc.c  */
+#line 1836 "parser.yy"
+    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
+    break;
+
+  case 482:
+
+/* Line 1806 of yacc.c  */
 #line 1838 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 481:
-
-/* Line 1806 of yacc.c  */
-#line 1843 "parser.yy"
-    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
-    break;
-
-  case 482:
-
-/* Line 1806 of yacc.c  */
-#line 1845 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -7520 +7516 @@
 
 /* Line 1806 of yacc.c  */
-#line 1851 "parser.yy"
+#line 1844 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Type; }
     break;
@@ -7527 +7523 @@
 
 /* Line 1806 of yacc.c  */
+#line 1846 "parser.yy"
+    { (yyval.tclass) = DeclarationNode::Ftype; }
+    break;
+
+  case 486:
+
+/* Line 1806 of yacc.c  */
+#line 1848 "parser.yy"
+    { (yyval.tclass) = DeclarationNode::Dtype; }
+    break;
+
+  case 487:
+
+/* Line 1806 of yacc.c  */
 #line 1853 "parser.yy"
-    { (yyval.tclass) = DeclarationNode::Ftype; }
-    break;
-
-  case 486:
+    { (yyval.decl) = 0; }
+    break;
+
+  case 488:
 
 /* Line 1806 of yacc.c  */
 #line 1855 "parser.yy"
-    { (yyval.tclass) = DeclarationNode::Dtype; }
-    break;
-
-  case 487:
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
+    break;
+
+  case 489:
 
 /* Line 1806 of yacc.c  */
 #line 1860 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 488:
-
-/* Line 1806 of yacc.c  */
-#line 1862 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 489:
-
-/* Line 1806 of yacc.c  */
-#line 1867 "parser.yy"
     {
                         typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
@@ -7565 +7561 @@
 
 /* Line 1806 of yacc.c  */
+#line 1865 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
+    break;
+
+  case 491:
+
+/* Line 1806 of yacc.c  */
+#line 1867 "parser.yy"
+    { (yyval.decl) = 0; }
+    break;
+
+  case 492:
+
+/* Line 1806 of yacc.c  */
 #line 1872 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
-    break;
-
-  case 491:
-
-/* Line 1806 of yacc.c  */
-#line 1874 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
-  case 492:
-
-/* Line 1806 of yacc.c  */
-#line 1879 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
     break;
@@ -7586 +7582 @@
 
 /* Line 1806 of yacc.c  */
+#line 1875 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
+    break;
+
+  case 495:
+
+/* Line 1806 of yacc.c  */
+#line 1877 "parser.yy"
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
+    break;
+
+  case 496:
+
+/* Line 1806 of yacc.c  */
 #line 1882 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
-    break;
-
-  case 495:
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
+    break;
+
+  case 497:
 
 /* Line 1806 of yacc.c  */
 #line 1884 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
-    break;
-
-  case 496:
-
-/* Line 1806 of yacc.c  */
-#line 1889 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 497:
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
+    break;
+
+  case 498:
+
+/* Line 1806 of yacc.c  */
+#line 1886 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 499:
 
 /* Line 1806 of yacc.c  */
 #line 1891 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 498:
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 500:
 
 /* Line 1806 of yacc.c  */
 #line 1893 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 499:
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 501:
 
 /* Line 1806 of yacc.c  */
 #line 1898 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 500:
-
-/* Line 1806 of yacc.c  */
-#line 1900 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 501:
-
-/* Line 1806 of yacc.c  */
-#line 1905 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
@@ -7645 +7641 @@
 
 /* Line 1806 of yacc.c  */
-#line 1910 "parser.yy"
+#line 1903 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
@@ -7655 +7651 @@
 
 /* Line 1806 of yacc.c  */
-#line 1918 "parser.yy"
+#line 1911 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
@@ -7665 +7661 @@
 
 /* Line 1806 of yacc.c  */
-#line 1923 "parser.yy"
+#line 1916 "parser.yy"
     {
                         typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
@@ -7675 +7671 @@
 
 /* Line 1806 of yacc.c  */
-#line 1928 "parser.yy"
+#line 1921 "parser.yy"
     {
                         typedefTable.leaveTrait();
@@ -7686 +7682 @@
 
 /* Line 1806 of yacc.c  */
-#line 1938 "parser.yy"
+#line 1931 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7693 +7689 @@
 
 /* Line 1806 of yacc.c  */
-#line 1948 "parser.yy"
+#line 1941 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7703 +7699 @@
 
 /* Line 1806 of yacc.c  */
-#line 1953 "parser.yy"
+#line 1946 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7713 +7709 @@
 
 /* Line 1806 of yacc.c  */
-#line 1958 "parser.yy"
+#line 1951 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -7723 +7719 @@
 
 /* Line 1806 of yacc.c  */
-#line 1966 "parser.yy"
+#line 1959 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7733 +7729 @@
 
 /* Line 1806 of yacc.c  */
-#line 1971 "parser.yy"
+#line 1964 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7743 +7739 @@
 
 /* Line 1806 of yacc.c  */
-#line 1981 "parser.yy"
+#line 1974 "parser.yy"
     {}
     break;
@@ -7750 +7746 @@
 
 /* Line 1806 of yacc.c  */
-#line 1983 "parser.yy"
+#line 1976 "parser.yy"
     {
                         if ( theTree ) {
@@ -7763 +7759 @@
 
 /* Line 1806 of yacc.c  */
-#line 1995 "parser.yy"
+#line 1988 "parser.yy"
     { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
     break;
@@ -7770 +7766 @@
 
 /* Line 1806 of yacc.c  */
-#line 2000 "parser.yy"
+#line 1993 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7777 +7773 @@
 
 /* Line 1806 of yacc.c  */
-#line 2008 "parser.yy"
+#line 2001 "parser.yy"
     {}
     break;
@@ -7784 +7780 @@
 
 /* Line 1806 of yacc.c  */
-#line 2010 "parser.yy"
+#line 2003 "parser.yy"
     {
                         linkageStack.push( linkage );
@@ -7794 +7790 @@
 
 /* Line 1806 of yacc.c  */
-#line 2015 "parser.yy"
+#line 2008 "parser.yy"
     {