Changeset 6603c1d

Timestamp:

Aug 15, 2016, 10:18:22 AM (9 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"
     {
                         linkage = linkageStack.top();
@@ -7805 +7801 @@
 
 /* Line 1806 of yacc.c  */
-#line 2021 "parser.yy"
+#line 2014 "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.decl) = (yyvsp[(2) - (2)].decl);
@@ -7816 +7812 @@
 
 /* Line 1806 of yacc.c  */
-#line 2036 "parser.yy"
+#line 2029 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7827 +7823 @@
 
 /* Line 1806 of yacc.c  */
-#line 2042 "parser.yy"
+#line 2035 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7838 +7834 @@
 
 /* Line 1806 of yacc.c  */
-#line 2051 "parser.yy"
+#line 2044 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7849 +7845 @@
 
 /* Line 1806 of yacc.c  */
-#line 2057 "parser.yy"
+#line 2050 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7860 +7856 @@
 
 /* Line 1806 of yacc.c  */
-#line 2063 "parser.yy"
+#line 2056 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7871 +7867 @@
 
 /* Line 1806 of yacc.c  */
-#line 2069 "parser.yy"
+#line 2062 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7882 +7878 @@
 
 /* Line 1806 of yacc.c  */
-#line 2075 "parser.yy"
+#line 2068 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7893 +7889 @@
 
 /* Line 1806 of yacc.c  */
-#line 2083 "parser.yy"
+#line 2076 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7904 +7900 @@
 
 /* Line 1806 of yacc.c  */
-#line 2089 "parser.yy"
+#line 2082 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7915 +7911 @@
 
 /* Line 1806 of yacc.c  */
-#line 2097 "parser.yy"
+#line 2090 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7926 +7922 @@
 
 /* Line 1806 of yacc.c  */
-#line 2103 "parser.yy"
+#line 2096 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7937 +7933 @@
 
 /* Line 1806 of yacc.c  */
-#line 2118 "parser.yy"
+#line 2111 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -7944 +7940 @@
 
 /* Line 1806 of yacc.c  */
+#line 2121 "parser.yy"
+    { (yyval.decl) = 0; }
+    break;
+
+  case 548:
+
+/* Line 1806 of yacc.c  */
 #line 2128 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 549:
+
+/* Line 1806 of yacc.c  */
+#line 2134 "parser.yy"
     { (yyval.decl) = 0; }
     break;
 
-  case 548:
-
-/* Line 1806 of yacc.c  */
-#line 2135 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 549:
-
-/* Line 1806 of yacc.c  */
-#line 2141 "parser.yy"
-    { (yyval.decl) = 0; }
-    break;
-
   case 555:
 
 /* Line 1806 of yacc.c  */
-#line 2156 "parser.yy"
+#line 2149 "parser.yy"
     {}
     break;
@@ -7972 +7968 @@
 
 /* Line 1806 of yacc.c  */
-#line 2157 "parser.yy"
+#line 2150 "parser.yy"
     {}
     break;
@@ -7979 +7975 @@
 
 /* Line 1806 of yacc.c  */
-#line 2158 "parser.yy"
+#line 2151 "parser.yy"
     {}
     break;
@@ -7986 +7982 @@
 
 /* Line 1806 of yacc.c  */
-#line 2159 "parser.yy"
+#line 2152 "parser.yy"
     {}
     break;
@@ -7993 +7989 @@
 
 /* Line 1806 of yacc.c  */
-#line 2194 "parser.yy"
+#line 2187 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8000 +7996 @@
 
 /* Line 1806 of yacc.c  */
+#line 2190 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 562:
+
+/* Line 1806 of yacc.c  */
+#line 2192 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 563:
+
+/* Line 1806 of yacc.c  */
 #line 2197 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 562:
-
-/* Line 1806 of yacc.c  */
-#line 2199 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 563:
-
-/* Line 1806 of yacc.c  */
-#line 2204 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8024 +8020 @@
 
 /* Line 1806 of yacc.c  */
+#line 2202 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 565:
+
+/* Line 1806 of yacc.c  */
+#line 2207 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 566:
+
+/* Line 1806 of yacc.c  */
 #line 2209 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 567:
+
+/* Line 1806 of yacc.c  */
+#line 2211 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 565:
-
-/* Line 1806 of yacc.c  */
-#line 2214 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 566:
+  case 568:
 
 /* Line 1806 of yacc.c  */
 #line 2216 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 567:
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 569:
 
 /* Line 1806 of yacc.c  */
 #line 2218 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 570:
+
+/* Line 1806 of yacc.c  */
+#line 2220 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 571:
+
+/* Line 1806 of yacc.c  */
+#line 2222 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 568:
-
-/* Line 1806 of yacc.c  */
-#line 2223 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 569:
-
-/* Line 1806 of yacc.c  */
-#line 2225 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 570:
+  case 572:
 
 /* Line 1806 of yacc.c  */
 #line 2227 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 571:
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 573:
 
 /* Line 1806 of yacc.c  */
@@ -8077 +8087 @@
     break;
 
-  case 572:
-
-/* Line 1806 of yacc.c  */
-#line 2234 "parser.yy"
+  case 574:
+
+/* Line 1806 of yacc.c  */
+#line 2238 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 576:
+
+/* Line 1806 of yacc.c  */
+#line 2241 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 577:
+
+/* Line 1806 of yacc.c  */
+#line 2246 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+
+  case 578:
+
+/* Line 1806 of yacc.c  */
+#line 2248 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 573:
-
-/* Line 1806 of yacc.c  */
-#line 2236 "parser.yy"
+  case 579:
+
+/* Line 1806 of yacc.c  */
+#line 2250 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 574:
-
-/* Line 1806 of yacc.c  */
-#line 2245 "parser.yy"
+  case 580:
+
+/* Line 1806 of yacc.c  */
+#line 2255 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 581:
+
+/* Line 1806 of yacc.c  */
+#line 2257 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 582:
+
+/* Line 1806 of yacc.c  */
+#line 2259 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 583:
+
+/* Line 1806 of yacc.c  */
+#line 2264 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 584:
+
+/* Line 1806 of yacc.c  */
+#line 2266 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 585:
+
+/* Line 1806 of yacc.c  */
+#line 2268 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 589:
+
+/* Line 1806 of yacc.c  */
+#line 2283 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
+    break;
+
+  case 590:
+
+/* Line 1806 of yacc.c  */
+#line 2285 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
+    break;
+
+  case 591:
+
+/* Line 1806 of yacc.c  */
+#line 2287 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 592:
+
+/* Line 1806 of yacc.c  */
+#line 2292 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 593:
+
+/* Line 1806 of yacc.c  */
+#line 2294 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 594:
+
+/* Line 1806 of yacc.c  */
+#line 2296 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 595:
+
+/* Line 1806 of yacc.c  */
+#line 2301 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 596:
+
+/* Line 1806 of yacc.c  */
+#line 2303 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 597:
+
+/* Line 1806 of yacc.c  */
+#line 2305 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 598:
+
+/* Line 1806 of yacc.c  */
+#line 2320 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 576:
-
-/* Line 1806 of yacc.c  */
-#line 2248 "parser.yy"
+  case 600:
+
+/* Line 1806 of yacc.c  */
+#line 2323 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 577:
-
-/* Line 1806 of yacc.c  */
-#line 2253 "parser.yy"
+  case 601:
+
+/* Line 1806 of yacc.c  */
+#line 2325 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 603:
+
+/* Line 1806 of yacc.c  */
+#line 2331 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 604:
+
+/* Line 1806 of yacc.c  */
+#line 2336 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 605:
+
+/* Line 1806 of yacc.c  */
+#line 2338 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 606:
+
+/* Line 1806 of yacc.c  */
+#line 2340 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 607:
+
+/* Line 1806 of yacc.c  */
+#line 2345 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 608:
+
+/* Line 1806 of yacc.c  */
+#line 2347 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 609:
+
+/* Line 1806 of yacc.c  */
+#line 2349 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 610:
+
+/* Line 1806 of yacc.c  */
+#line 2351 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 611:
+
+/* Line 1806 of yacc.c  */
+#line 2356 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
 
-  case 578:
-
-/* Line 1806 of yacc.c  */
-#line 2255 "parser.yy"
+  case 612:
+
+/* Line 1806 of yacc.c  */
+#line 2358 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 579:
-
-/* Line 1806 of yacc.c  */
-#line 2257 "parser.yy"
+  case 613:
+
+/* Line 1806 of yacc.c  */
+#line 2360 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 580:
-
-/* Line 1806 of yacc.c  */
-#line 2262 "parser.yy"
+  case 614:
+
+/* Line 1806 of yacc.c  */
+#line 2370 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 616:
+
+/* Line 1806 of yacc.c  */
+#line 2373 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 617:
+
+/* Line 1806 of yacc.c  */
+#line 2375 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 618:
+
+/* Line 1806 of yacc.c  */
+#line 2380 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 
-  case 581:
-
-/* Line 1806 of yacc.c  */
-#line 2264 "parser.yy"
+  case 619:
+
+/* Line 1806 of yacc.c  */
+#line 2382 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 
-  case 582:
-
-/* Line 1806 of yacc.c  */
-#line 2266 "parser.yy"
+  case 620:
+
+/* Line 1806 of yacc.c  */
+#line 2384 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 583:
-
-/* Line 1806 of yacc.c  */
-#line 2271 "parser.yy"
+  case 621:
+
+/* Line 1806 of yacc.c  */
+#line 2389 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 622:
+
+/* Line 1806 of yacc.c  */
+#line 2391 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 584:
-
-/* Line 1806 of yacc.c  */
-#line 2273 "parser.yy"
+  case 623:
+
+/* Line 1806 of yacc.c  */
+#line 2393 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 585:
-
-/* Line 1806 of yacc.c  */
-#line 2275 "parser.yy"
+  case 624:
+
+/* Line 1806 of yacc.c  */
+#line 2395 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 589:
-
-/* Line 1806 of yacc.c  */
-#line 2290 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 590:
-
-/* Line 1806 of yacc.c  */
-#line 2292 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
-    break;
-
-  case 591:
-
-/* Line 1806 of yacc.c  */
-#line 2294 "parser.yy"
+  case 625:
+
+/* Line 1806 of yacc.c  */
+#line 2400 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+
+  case 626:
+
+/* Line 1806 of yacc.c  */
+#line 2402 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 627:
+
+/* Line 1806 of yacc.c  */
+#line 2404 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 592:
-
-/* Line 1806 of yacc.c  */
-#line 2299 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 593:
-
-/* Line 1806 of yacc.c  */
-#line 2301 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 594:
-
-/* Line 1806 of yacc.c  */
-#line 2303 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 595:
-
-/* Line 1806 of yacc.c  */
-#line 2308 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 596:
-
-/* Line 1806 of yacc.c  */
-#line 2310 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 597:
-
-/* Line 1806 of yacc.c  */
-#line 2312 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 598:
-
-/* Line 1806 of yacc.c  */
-#line 2327 "parser.yy"
+  case 628:
+
+/* Line 1806 of yacc.c  */
+#line 2435 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 600:
-
-/* Line 1806 of yacc.c  */
-#line 2330 "parser.yy"
+  case 630:
+
+/* Line 1806 of yacc.c  */
+#line 2438 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 601:
-
-/* Line 1806 of yacc.c  */
-#line 2332 "parser.yy"
+  case 631:
+
+/* Line 1806 of yacc.c  */
+#line 2440 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 603:
-
-/* Line 1806 of yacc.c  */
-#line 2338 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 604:
-
-/* Line 1806 of yacc.c  */
-#line 2343 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 605:
-
-/* Line 1806 of yacc.c  */
-#line 2345 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 606:
-
-/* Line 1806 of yacc.c  */
-#line 2347 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 607:
-
-/* Line 1806 of yacc.c  */
-#line 2352 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 608:
-
-/* Line 1806 of yacc.c  */
-#line 2354 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 609:
-
-/* Line 1806 of yacc.c  */
-#line 2356 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 610:
-
-/* Line 1806 of yacc.c  */
-#line 2358 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 611:
-
-/* Line 1806 of yacc.c  */
-#line 2363 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 612:
-
-/* Line 1806 of yacc.c  */
-#line 2365 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 613:
-
-/* Line 1806 of yacc.c  */
-#line 2367 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 614:
-
-/* Line 1806 of yacc.c  */
-#line 2377 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 616:
-
-/* Line 1806 of yacc.c  */
-#line 2380 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 617:
-
-/* Line 1806 of yacc.c  */
-#line 2382 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 618:
-
-/* Line 1806 of yacc.c  */
-#line 2387 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 619:
-
-/* Line 1806 of yacc.c  */
-#line 2389 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 620:
-
-/* Line 1806 of yacc.c  */
-#line 2391 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 621:
-
-/* Line 1806 of yacc.c  */
-#line 2396 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 622:
-
-/* Line 1806 of yacc.c  */
-#line 2398 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 623:
-
-/* Line 1806 of yacc.c  */
-#line 2400 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 624:
-
-/* Line 1806 of yacc.c  */
-#line 2402 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 625:
-
-/* Line 1806 of yacc.c  */
-#line 2407 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 626:
-
-/* Line 1806 of yacc.c  */
-#line 2409 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 627:
-
-/* Line 1806 of yacc.c  */
-#line 2411 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 628:
-
-/* Line 1806 of yacc.c  */
-#line 2442 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 630:
+  case 632:
 
 /* Line 1806 of yacc.c  */
 #line 2445 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 631:
-
-/* Line 1806 of yacc.c  */
-#line 2447 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 632:
-
-/* Line 1806 of yacc.c  */
-#line 2452 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8454 +8450 @@
 
 /* Line 1806 of yacc.c  */
-#line 2457 "parser.yy"
+#line 2450 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8464 +8460 @@
 
 /* Line 1806 of yacc.c  */
-#line 2465 "parser.yy"
+#line 2458 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8471 +8467 @@
 
 /* Line 1806 of yacc.c  */
+#line 2460 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 636:
+
+/* Line 1806 of yacc.c  */
+#line 2462 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 637:
+
+/* Line 1806 of yacc.c  */
 #line 2467 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 638:
+
+/* Line 1806 of yacc.c  */
+#line 2469 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 639:
+
+/* Line 1806 of yacc.c  */
+#line 2474 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+
+  case 640:
+
+/* Line 1806 of yacc.c  */
+#line 2476 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 642:
+
+/* Line 1806 of yacc.c  */
+#line 2491 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 643:
+
+/* Line 1806 of yacc.c  */
+#line 2493 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 644:
+
+/* Line 1806 of yacc.c  */
+#line 2498 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
+    break;
+
+  case 645:
+
+/* Line 1806 of yacc.c  */
+#line 2500 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 646:
+
+/* Line 1806 of yacc.c  */
+#line 2502 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 647:
+
+/* Line 1806 of yacc.c  */
+#line 2504 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 
-  case 636:
-
-/* Line 1806 of yacc.c  */
-#line 2469 "parser.yy"
+  case 648:
+
+/* Line 1806 of yacc.c  */
+#line 2506 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 637:
-
-/* Line 1806 of yacc.c  */
-#line 2474 "parser.yy"
+  case 650:
+
+/* Line 1806 of yacc.c  */
+#line 2512 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 651:
+
+/* Line 1806 of yacc.c  */
+#line 2514 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 652:
+
+/* Line 1806 of yacc.c  */
+#line 2516 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 653:
+
+/* Line 1806 of yacc.c  */
+#line 2521 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
+    break;
+
+  case 654:
+
+/* Line 1806 of yacc.c  */
+#line 2523 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 655:
+
+/* Line 1806 of yacc.c  */
+#line 2525 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 656:
+
+/* Line 1806 of yacc.c  */
+#line 2531 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
+    break;
+
+  case 657:
+
+/* Line 1806 of yacc.c  */
+#line 2533 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 659:
+
+/* Line 1806 of yacc.c  */
+#line 2539 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
+    break;
+
+  case 660:
+
+/* Line 1806 of yacc.c  */
+#line 2541 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
+    break;
+
+  case 661:
+
+/* Line 1806 of yacc.c  */
+#line 2543 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
+    break;
+
+  case 662:
+
+/* Line 1806 of yacc.c  */
+#line 2545 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
+    break;
+
+  case 664:
+
+/* Line 1806 of yacc.c  */
+#line 2560 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 665:
+
+/* Line 1806 of yacc.c  */
+#line 2562 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 666:
+
+/* Line 1806 of yacc.c  */
+#line 2567 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
+    break;
+
+  case 667:
+
+/* Line 1806 of yacc.c  */
+#line 2569 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 668:
+
+/* Line 1806 of yacc.c  */
+#line 2571 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 669:
+
+/* Line 1806 of yacc.c  */
+#line 2573 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 670:
+
+/* Line 1806 of yacc.c  */
+#line 2575 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 672:
+
+/* Line 1806 of yacc.c  */
+#line 2581 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 673:
+
+/* Line 1806 of yacc.c  */
+#line 2583 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 674:
+
+/* Line 1806 of yacc.c  */
+#line 2585 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 675:
+
+/* Line 1806 of yacc.c  */
+#line 2590 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
+    break;
+
+  case 676:
+
+/* Line 1806 of yacc.c  */
+#line 2592 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 677:
+
+/* Line 1806 of yacc.c  */
+#line 2594 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 679:
+
+/* Line 1806 of yacc.c  */
+#line 2601 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 638:
-
-/* Line 1806 of yacc.c  */
-#line 2476 "parser.yy"
+  case 681:
+
+/* Line 1806 of yacc.c  */
+#line 2612 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
+    break;
+
+  case 682:
+
+/* Line 1806 of yacc.c  */
+#line 2615 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+
+  case 683:
+
+/* Line 1806 of yacc.c  */
+#line 2617 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
+    break;
+
+  case 684:
+
+/* Line 1806 of yacc.c  */
+#line 2620 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+
+  case 685:
+
+/* Line 1806 of yacc.c  */
+#line 2622 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
+    break;
+
+  case 686:
+
+/* Line 1806 of yacc.c  */
+#line 2624 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
+    break;
+
+  case 688:
+
+/* Line 1806 of yacc.c  */
+#line 2638 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 689:
+
+/* Line 1806 of yacc.c  */
+#line 2640 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 690:
+
+/* Line 1806 of yacc.c  */
+#line 2645 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
+    break;
+
+  case 691:
+
+/* Line 1806 of yacc.c  */
+#line 2647 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 692:
+
+/* Line 1806 of yacc.c  */
+#line 2649 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 693:
+
+/* Line 1806 of yacc.c  */
+#line 2651 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 694:
+
+/* Line 1806 of yacc.c  */
+#line 2653 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 696:
+
+/* Line 1806 of yacc.c  */
+#line 2659 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 639:
-
-/* Line 1806 of yacc.c  */
-#line 2481 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 640:
-
-/* Line 1806 of yacc.c  */
-#line 2483 "parser.yy"
+  case 697:
+
+/* Line 1806 of yacc.c  */
+#line 2661 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 698:
+
+/* Line 1806 of yacc.c  */
+#line 2663 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 699:
+
+/* Line 1806 of yacc.c  */
+#line 2668 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 642:
-
-/* Line 1806 of yacc.c  */
-#line 2498 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 643:
-
-/* Line 1806 of yacc.c  */
-#line 2500 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 644:
-
-/* Line 1806 of yacc.c  */
-#line 2505 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 645:
-
-/* Line 1806 of yacc.c  */
-#line 2507 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 646:
-
-/* Line 1806 of yacc.c  */
-#line 2509 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 647:
-
-/* Line 1806 of yacc.c  */
-#line 2511 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 648:
-
-/* Line 1806 of yacc.c  */
-#line 2513 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 650:
-
-/* Line 1806 of yacc.c  */
-#line 2519 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 651:
-
-/* Line 1806 of yacc.c  */
-#line 2521 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 652:
-
-/* Line 1806 of yacc.c  */
-#line 2523 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 653:
-
-/* Line 1806 of yacc.c  */
-#line 2528 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
-    break;
-
-  case 654:
-
-/* Line 1806 of yacc.c  */
-#line 2530 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 655:
-
-/* Line 1806 of yacc.c  */
-#line 2532 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 656:
-
-/* Line 1806 of yacc.c  */
-#line 2538 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-
-  case 657:
-
-/* Line 1806 of yacc.c  */
-#line 2540 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 659:
-
-/* Line 1806 of yacc.c  */
-#line 2546 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
-    break;
-
-  case 660:
-
-/* Line 1806 of yacc.c  */
-#line 2548 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
-    break;
-
-  case 661:
-
-/* Line 1806 of yacc.c  */
-#line 2550 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
-    break;
-
-  case 662:
-
-/* Line 1806 of yacc.c  */
-#line 2552 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
-    break;
-
-  case 664:
-
-/* Line 1806 of yacc.c  */
-#line 2567 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 665:
-
-/* Line 1806 of yacc.c  */
-#line 2569 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 666:
-
-/* Line 1806 of yacc.c  */
-#line 2574 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 667:
-
-/* Line 1806 of yacc.c  */
-#line 2576 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 668:
-
-/* Line 1806 of yacc.c  */
-#line 2578 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 669:
-
-/* Line 1806 of yacc.c  */
-#line 2580 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 670:
-
-/* Line 1806 of yacc.c  */
-#line 2582 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 672:
-
-/* Line 1806 of yacc.c  */
-#line 2588 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 673:
-
-/* Line 1806 of yacc.c  */
-#line 2590 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 674:
-
-/* Line 1806 of yacc.c  */
-#line 2592 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 675:
-
-/* Line 1806 of yacc.c  */
-#line 2597 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
-    break;
-
-  case 676:
-
-/* Line 1806 of yacc.c  */
-#line 2599 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 677:
-
-/* Line 1806 of yacc.c  */
-#line 2601 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 679:
-
-/* Line 1806 of yacc.c  */
-#line 2608 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 681:
-
-/* Line 1806 of yacc.c  */
-#line 2619 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-
-  case 682:
-
-/* Line 1806 of yacc.c  */
-#line 2622 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 683:
-
-/* Line 1806 of yacc.c  */
-#line 2624 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
-    break;
-
-  case 684:
-
-/* Line 1806 of yacc.c  */
-#line 2627 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 685:
-
-/* Line 1806 of yacc.c  */
-#line 2629 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
-    break;
-
-  case 686:
-
-/* Line 1806 of yacc.c  */
-#line 2631 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
-    break;
-
-  case 688:
-
-/* Line 1806 of yacc.c  */
-#line 2645 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 689:
-
-/* Line 1806 of yacc.c  */
-#line 2647 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 690:
-
-/* Line 1806 of yacc.c  */
-#line 2652 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 691:
-
-/* Line 1806 of yacc.c  */
-#line 2654 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 692:
-
-/* Line 1806 of yacc.c  */
-#line 2656 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 693:
-
-/* Line 1806 of yacc.c  */
-#line 2658 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 694:
-
-/* Line 1806 of yacc.c  */
-#line 2660 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 696:
-
-/* Line 1806 of yacc.c  */
-#line 2666 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 697:
-
-/* Line 1806 of yacc.c  */
-#line 2668 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 698:
+  case 700:
 
 /* Line 1806 of yacc.c  */
@@ -8853 +8863 @@
     break;
 
-  case 699:
-
-/* Line 1806 of yacc.c  */
-#line 2675 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 700:
-
-/* Line 1806 of yacc.c  */
-#line 2677 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
   case 703:
 
 /* Line 1806 of yacc.c  */
-#line 2687 "parser.yy"
+#line 2680 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -8877 +8873 @@
 
 /* Line 1806 of yacc.c  */
-#line 2697 "parser.yy"
+#line 2690 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8884 +8880 @@
 
 /* Line 1806 of yacc.c  */
-#line 2699 "parser.yy"
+#line 2692 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -8891 +8887 @@
 
 /* Line 1806 of yacc.c  */
-#line 2701 "parser.yy"
+#line 2694 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8898 +8894 @@
 
 /* Line 1806 of yacc.c  */
-#line 2703 "parser.yy"
+#line 2696 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -8905 +8901 @@
 
 /* Line 1806 of yacc.c  */
-#line 2705 "parser.yy"
+#line 2698 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8912 +8908 @@
 
 /* Line 1806 of yacc.c  */
+#line 2700 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 712:
+
+/* Line 1806 of yacc.c  */
 #line 2707 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 713:
+
+/* Line 1806 of yacc.c  */
+#line 2709 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 714:
+
+/* Line 1806 of yacc.c  */
+#line 2711 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 715:
+
+/* Line 1806 of yacc.c  */
+#line 2713 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
+    break;
+
+  case 716:
+
+/* Line 1806 of yacc.c  */
+#line 2715 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 717:
+
+/* Line 1806 of yacc.c  */
+#line 2717 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 718:
+
+/* Line 1806 of yacc.c  */
+#line 2719 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 719:
+
+/* Line 1806 of yacc.c  */
+#line 2721 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 720:
+
+/* Line 1806 of yacc.c  */
+#line 2723 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
+    break;
+
+  case 721:
+
+/* Line 1806 of yacc.c  */
+#line 2725 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 722:
+
+/* Line 1806 of yacc.c  */
+#line 2730 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+
+  case 723:
+
+/* Line 1806 of yacc.c  */
+#line 2732 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+
+  case 724:
+
+/* Line 1806 of yacc.c  */
+#line 2737 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
+    break;
+
+  case 725:
+
+/* Line 1806 of yacc.c  */
+#line 2739 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
+    break;
+
+  case 727:
+
+/* Line 1806 of yacc.c  */
+#line 2766 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 731:
+
+/* Line 1806 of yacc.c  */
+#line 2777 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 732:
+
+/* Line 1806 of yacc.c  */
+#line 2779 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
 
-  case 712:
-
-/* Line 1806 of yacc.c  */
-#line 2714 "parser.yy"
+  case 733:
+
+/* Line 1806 of yacc.c  */
+#line 2781 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 734:
+
+/* Line 1806 of yacc.c  */
+#line 2783 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 735:
+
+/* Line 1806 of yacc.c  */
+#line 2785 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 736:
+
+/* Line 1806 of yacc.c  */
+#line 2787 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 737:
+
+/* Line 1806 of yacc.c  */
+#line 2794 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
 
-  case 713:
-
-/* Line 1806 of yacc.c  */
-#line 2716 "parser.yy"
+  case 738:
+
+/* Line 1806 of yacc.c  */
+#line 2796 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 739:
+
+/* Line 1806 of yacc.c  */
+#line 2798 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 714:
-
-/* Line 1806 of yacc.c  */
-#line 2718 "parser.yy"
+  case 740:
+
+/* Line 1806 of yacc.c  */
+#line 2800 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 741:
+
+/* Line 1806 of yacc.c  */
+#line 2802 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
 
-  case 715:
-
-/* Line 1806 of yacc.c  */
-#line 2720 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 716:
-
-/* Line 1806 of yacc.c  */
-#line 2722 "parser.yy"
+  case 742:
+
+/* Line 1806 of yacc.c  */
+#line 2804 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 717:
-
-/* Line 1806 of yacc.c  */
-#line 2724 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 718:
-
-/* Line 1806 of yacc.c  */
-#line 2726 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 719:
-
-/* Line 1806 of yacc.c  */
-#line 2728 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 720:
-
-/* Line 1806 of yacc.c  */
-#line 2730 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 721:
-
-/* Line 1806 of yacc.c  */
-#line 2732 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 722:
-
-/* Line 1806 of yacc.c  */
-#line 2737 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 723:
-
-/* Line 1806 of yacc.c  */
-#line 2739 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 724:
-
-/* Line 1806 of yacc.c  */
-#line 2744 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
-    break;
-
-  case 725:
-
-/* Line 1806 of yacc.c  */
-#line 2746 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
-    break;
-
-  case 727:
-
-/* Line 1806 of yacc.c  */
-#line 2773 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 731:
-
-/* Line 1806 of yacc.c  */
-#line 2784 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 732:
-
-/* Line 1806 of yacc.c  */
-#line 2786 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 733:
-
-/* Line 1806 of yacc.c  */
-#line 2788 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 734:
-
-/* Line 1806 of yacc.c  */
-#line 2790 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 735:
-
-/* Line 1806 of yacc.c  */
-#line 2792 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 736:
-
-/* Line 1806 of yacc.c  */
-#line 2794 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 737:
-
-/* Line 1806 of yacc.c  */
-#line 2801 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 738:
-
-/* Line 1806 of yacc.c  */
-#line 2803 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 739:
-
-/* Line 1806 of yacc.c  */
-#line 2805 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 740:
-
-/* Line 1806 of yacc.c  */
-#line 2807 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 741:
+  case 743:
 
 /* Line 1806 of yacc.c  */
 #line 2809 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 742:
-
-/* Line 1806 of yacc.c  */
-#line 2811 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 743:
+    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
+    break;
+
+  case 744:
+
+/* Line 1806 of yacc.c  */
+#line 2814 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
+    break;
+
+  case 745:
 
 /* Line 1806 of yacc.c  */
 #line 2816 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
-    break;
-
-  case 744:
-
-/* Line 1806 of yacc.c  */
-#line 2821 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
-    break;
-
-  case 745:
-
-/* Line 1806 of yacc.c  */
-#line 2823 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
     break;
@@ -9129 +9125 @@
 
 /* Line 1806 of yacc.c  */
-#line 2825 "parser.yy"
+#line 2818 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
     break;
@@ -9136 +9132 @@
 
 /* Line 1806 of yacc.c  */
-#line 2849 "parser.yy"
+#line 2842 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -9143 +9139 @@
 
 /* Line 1806 of yacc.c  */
-#line 2851 "parser.yy"
+#line 2844 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -9150 +9146 @@
 
 /* Line 1806 of yacc.c  */
-#line 9153 "Parser/parser.cc"
+#line 9149 "Parser/parser.cc"
       default: break;
     }
@@ -9381 +9377 @@
 
 /* Line 2067 of yacc.c  */
-#line 2854 "parser.yy"
+#line 2847 "parser.yy"
 
 // ----end of grammar----

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 11 18:02:57 2016
-// Update Count     : 1861
+// Last Modified On : Sun Aug 14 11:03:22 2016
+// Update Count     : 1879
 //
 
@@ -143 +143 @@
 %type<en> constant_expression                   assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
-//%type<en> argument_expression_list            argument_expression                     for_control_expression          assignment_opt
 %type<en> argument_expression_list              argument_expression                     assignment_opt
 %type<fctl> for_control_expression
@@ -162 +161 @@
 %type<sn> case_value_list                               case_label                                      case_label_list
 %type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
-%type<pn> handler_list                                  handler_clause                          finally_clause
+%type<sn> handler_list                                  handler_clause                          finally_clause
 
 // declarations
@@ -389 +388 @@
                         Token fn;
                         fn.str = new std::string( "?{}" ); // location undefined
-                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
+                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) );
                 }
         ;
@@ -396 +395 @@
         argument_expression
         | argument_expression_list ',' argument_expression
-                { $$ = (ExpressionNode *)( $1->set_link( $3 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
         ;
 
@@ -407 +406 @@
 field_list:                                                                                             // CFA, tuple field selector
         field
-        | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_link( $3 ); }
+        | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -627 +626 @@
                 { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         | '[' push ',' tuple_expression_list pop ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); }
         | '[' push assignment_expression ',' tuple_expression_list pop ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); }
         ;
 
@@ -635 +634 @@
         assignment_expression_opt
         | tuple_expression_list ',' assignment_expression_opt
-                { $$ = (ExpressionNode *)$1->set_link( $3 ); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -665 +664 @@
                         Token fn;
                         fn.str = new std::string( "^?{}" ); // location undefined
-                        $$ = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_link( $4 ) ) ) ) );
+                        $$ = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) ) ) );
                 }
         ;
@@ -692 +691 @@
         block_item
         | block_item_list push block_item
-                { if ( $1 != 0 ) { $1->set_link( $3 ); $$ = $1; } }
+                { if ( $1 != 0 ) { $1->set_last( $3 ); $$ = $1; } }
         ;
 
 block_item:
         declaration                                                                                     // CFA, new & old style declarations
-                { $$ = new StatementNode( $1 ); }
+                { $$ = new StatementNode2( $1 ); }
         | EXTENSION declaration                                                         // GCC
                 {       // mark all fields in list
-                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_link() )
+                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_next() )
                                 iter->set_extension( true );
-                        $$ = new StatementNode( $2 );
+                        $$ = new StatementNode2( $2 );
                 }
         | function_definition
-                { $$ = new StatementNode( $1 ); }
+                { $$ = new StatementNode2( $1 ); }
         | statement pop
         ;
@@ -712 +711 @@
         statement
         | statement_list statement
-                { if ( $1 != 0 ) { $1->set_link( $2 ); $$ = $1; } }
+                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
         ;
 
@@ -736 +735 @@
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
-                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
+                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( $7 ))->set_last( sw )) ) : sw;
                 }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
@@ -743 +742 @@
                 {
                         StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
-                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
+                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( $7 ))->set_last( sw )) ) : sw;
                 }
         ;
@@ -758 +757 @@
 
 case_value_list:                                                                                // CFA
-        //case_value                                                                    { $$ = new StatementNode( StatementNode::Case, $1, 0 ); }
         case_value                                                                      { $$ = new StatementNode2( build_case( $1 ) ); }
                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
-        | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_link( new StatementNode2( build_case( $3 ) ) ) ); }
+        | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode2( build_case( $3 ) ) ) ); }
         ;
 
@@ -772 +770 @@
 case_label_list:                                                                                // CFA
         case_label
-        | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_link( $2 )); }
+        | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
         ;
 
@@ -789 +787 @@
                 { $$ = $1->append_last_case( new CompoundStmtNode( $2 ) ); }
         | switch_clause_list case_label_list statement_list
-                { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( new CompoundStmtNode( $3 ) ) ) ); }
+                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new CompoundStmtNode( $3 ) ) ) ); }
         ;
 
@@ -804 +802 @@
                 { $$ = $1->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$2, *$3 ) ) ) ); }
         | choose_clause_list case_label_list fall_through
-                { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( $3 ))); }
+                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( $3 ))); }
         | choose_clause_list case_label_list statement_list fall_through_opt
-                { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$3, *$4 ) ) ) ) ) ); }
+                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$3, *$4 ) ) ) ) ) ); }
         ;
 
@@ -871 +869 @@
 exception_statement:
         TRY compound_statement handler_list
-                { $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
+                { $$ = new StatementNode2( build_try( $2, $3, 0 ) ); }
         | TRY compound_statement finally_clause
-                { $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
+                { $$ = new StatementNode2( build_try( $2, 0, $3 ) ); }
         | TRY compound_statement handler_list finally_clause
-                {
-                        $3->set_link( $4 );
-                        $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 ))));
-                }
+                { $$ = new StatementNode2( build_try( $2, $3, $4 ) ); }
         ;
 
 handler_list:
-                // There must be at least one catch clause
         handler_clause
                 // ISO/IEC 9899:1999 Section 15.3(6 ) If present, a "..." handler shall be the last handler for its try block.
         | CATCH '(' ELLIPSIS ')' compound_statement
-                { $$ = StatementNode::newCatchStmt( 0, $5, true ); }
+                { $$ = new StatementNode2( build_catch( 0, $5, true ) ); }
         | handler_clause CATCH '(' ELLIPSIS ')' compound_statement
-                { $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode2( build_catch( 0, $6, true ) ) ); }
         | CATCHRESUME '(' ELLIPSIS ')' compound_statement
-                { $$ = StatementNode::newCatchStmt( 0, $5, true ); }
+                { $$ = new StatementNode2( build_catch( 0, $5, true ) ); }
         | handler_clause CATCHRESUME '(' ELLIPSIS ')' compound_statement
-                { $$ = $1->set_link( StatementNode::newCatchStmt( 0, $6, true ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode2( build_catch( 0, $6, true ) ) ); }
         ;
 
 handler_clause:
         CATCH '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = StatementNode::newCatchStmt( $5, $8 ); }
+                { $$ = new StatementNode2( build_catch( $5, $8 ) ); }
         | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = $1->set_link( StatementNode::newCatchStmt( $6, $9 ) ); }
+        { $$ = (StatementNode *)$1->set_last( new StatementNode2( build_catch( $6, $9 ) ) ); }
         | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = StatementNode::newCatchStmt( $5, $8 ); }
+                { $$ = new StatementNode2( build_catch( $5, $8 ) ); }
         | handler_clause CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-                { $$ = $1->set_link( StatementNode::newCatchStmt( $6, $9 ) ); }
+                { $$ = (StatementNode *)$1->set_last( new StatementNode2( build_catch( $6, $9 ) ) ); }
         ;
 
@@ -909 +903 @@
         FINALLY compound_statement
                 {
-                        $$ = new StatementNode( StatementNode::Finally, 0, $2 );
-                        std::cout << "Just created a finally node" << std::endl;
+                        $$ = new StatementNode2( build_finally( $2 ) );
                 }
         ;
@@ -938 +931 @@
 asm_statement:
         ASM asm_volatile_opt '(' string_literal_list ')' ';'
-                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, 0 ); }
+                { $$ = new AsmStmtNode( $2, $4, 0 ); }
         | ASM asm_volatile_opt '(' string_literal_list ':' asm_operands_opt ')' ';' // remaining GCC
-                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, $6 ); }
+                { $$ = new AsmStmtNode( $2, $4, $6 ); }
         | ASM asm_volatile_opt '(' string_literal_list ':' asm_operands_opt ':' asm_operands_opt ')' ';'
-                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, $6, $8 ); }
+                { $$ = new AsmStmtNode( $2, $4, $6, $8 ); }
         | ASM asm_volatile_opt '(' string_literal_list ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
-                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $4, $6, $8, $10 ); }
+                { $$ = new AsmStmtNode( $2, $4, $6, $8, $10 ); }
         | ASM asm_volatile_opt GOTO '(' string_literal_list ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
-                { $$ = new AsmStmtNode( StatementNode::Asm, $2, $5, 0, $8, $10, $12 ); }
+                { $$ = new AsmStmtNode( $2, $5, 0, $8, $10, $12 ); }
         ;
 
@@ -965 +958 @@
         asm_operand
         | asm_operands_list ',' asm_operand
-                { $$ = (ExpressionNode *)$1->set_link( $3 ); }
+                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -981 +974 @@
                 { $$ = new ExpressionNode( $1 ); }
         | asm_clobbers_list_opt ',' string_literal_list
-        { $$ = (ExpressionNode *)$1->set_link( new ExpressionNode( $3 ) ); }
+        { $$ = (ExpressionNode *)$1->set_last( new ExpressionNode( $3 ) ); }
         ;
 
@@ -1504 +1497 @@
         | EXTENSION field_declaring_list ';'                            // GCC
                 {       // mark all fields in list
-                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_link() )
+                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_next() )
                                 iter->set_extension( true );
                         $$ = $2;
@@ -1750 +1743 @@
         | initializer
         | designation initializer                                       { $$ = $2->set_designators( $1 ); }
-        | initializer_list ',' initializer                      { $$ = (InitializerNode *)( $1->set_link( $3 ) ); }
+        | initializer_list ',' initializer                      { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
         | initializer_list ',' designation initializer
-                { $$ = (InitializerNode *)( $1->set_link( $4->set_designators( $3 ) ) ); }
+                { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
         ;
 
@@ -1774 +1767 @@
         designator
         | designator_list designator
-                { $$ = (ExpressionNode *)( $1->set_link( $2 ) ); }
+                { $$ = (ExpressionNode *)( $1->set_last( $2 ) ); }
         //| designator_list designator                                          { $$ = new ExpressionNode( $1, $2 ); }
         ;
@@ -1880 +1873 @@
         | assignment_expression
         | type_name_list ',' type_name
-                { $$ = (ExpressionNode *)( $1->set_link( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
+                { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
         | type_name_list ',' assignment_expression
-                { $$ = (ExpressionNode *)( $1->set_link( $3 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
         ;
 
@@ -2020 +2013 @@
         | EXTENSION external_definition
                 {       // mark all fields in list
-                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_link() )
+                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_next() )
                                 iter->set_extension( true );
                         $$ = $2;

src/SynTree/Statement.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:25:20 2016
-// Update Count     : 61
+// Last Modified On : Fri Aug 12 13:58:48 2016
+// Update Count     : 62
 //
 
@@ -309 +309 @@
 }
 
-CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool isCatchRest ) :
-        Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest ) {
+CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool catchAny ) :
+        Statement( labels ), decl ( _decl ), body( _body ), catchRest ( catchAny ) {
 }
 

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:26:02 2016
-// Update Count     : 64
+// Last Modified On : Fri Aug 12 13:57:46 2016
+// Update Count     : 65
 //
 
@@ -314 +314 @@
 class CatchStmt : public Statement {
   public:
-        CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool isCatchRest = false );
+        CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool catchAny = false );
         CatchStmt( const CatchStmt &other );
         virtual ~CatchStmt();

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

@@ -100 +100 @@
     ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2));
 }
-__attribute__ ((constructor(),)) static void _init_extension(void){
-    int _global_init0;
-    ((void)((*((int *)(&__a__i_1)))=_global_init0) /* ?{} */);
-    int _global_init1;
-    ((void)((*((int *)(&__b__i_1)))=_global_init1) /* ?{} */);
-    int _global_init2;
-    ((void)((*((int *)(&__c__i_1)))=_global_init2) /* ?{} */);
-}
-__attribute__ ((destructor(),)) static void _destroy_extension(void){
-    ((void)((*((int *)(&__c__i_1)))) /* ^?{} */);
-    ((void)((*((int *)(&__b__i_1)))) /* ^?{} */);
-    ((void)((*((int *)(&__a__i_1)))) /* ^?{} */);
-}

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

@@ -5 +5 @@
 extern void exit(int __status);
 extern int printf(const char *__restrict __format, ...);
+extern int __x__i_1;
 int main(int __argc__i_1, const char **__argv__PPCc_1){
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
+    static int __y__i_2;
+    int __src__i_2;
+    int __dst__i_2;
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
+    asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     double _Complex __c1__Xd_2;
     double _Complex __c2__Xd_2;
@@ -151 +159 @@
     struct s4 __y2__3ss4_2;
     ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2))));
-    int __m1__A0i_2[((long unsigned int )10)];
-    int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
-    int __m3__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
+    int __m1__A0i_2[((unsigned int )10)];
+    int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
+    int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     int _retVal0 = { 0 };
     ((void)(_retVal0=0) /* ?{} */);

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

@@ -5 +5 @@
 extern void exit(int __status);
 extern int printf(const char *__restrict __format, ...);
+extern int __x__i_1;
 int main(int __argc__i_1, const char **__argv__PPCc_1){
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
+    static int __y__i_2;
+    int __src__i_2;
+    int __dst__i_2;
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" :  :  :  );
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) :  :  );
+    asm volatile ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) :  );
+    asm ( "mov %1, %0\n\tadd $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );
     double _Complex __c1__Xd_2;
     double _Complex __c2__Xd_2;

src/tests/exception.c

@@ -11 +11 @@
         x/4;
     } catch( int ) {
-    } catch( int x ) {
+    } catch( float x ) {
     } catch( struct { int i; } ) {
     } catch( struct { int i; } x ) {
@@ -21 +21 @@
     } catch( * struct { int i; } x ) {
     } catch( ... ) {
-//    } finally {
+    } finally {
     } // try
 }

src/tests/gccExtensions.c

@@ +1 @@
+// 
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// 
+// gccExtensions.c -- 
+// 
+// Author           : Peter A. Buhr
+// Created On       : Sun Aug 14 17:28:17 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Aug 14 17:36:28 2016
+// Update Count     : 3
+// 
+
+extern int x asm( "xx" );
+
 int main(int argc, char const *argv[]) {
         asm( "nop" );
@@ -4 +21 @@
         __asm__( "nop" );
 
+        static int y asm( "yy" );
+//      static * int z asm( "zz" );                                                     // CFA declaration
+
+        int src;
+        int dst;
+
+        asm volatile ( "mov %1, %0\n\t"
+                                   "add $1, %0" : : : );
+
+        asm volatile ( "mov %1, %0\n\t"
+                                   "add $1, %0"
+                                   : "=" "r" (dst));
+
+        asm volatile ( "mov %1, %0\n\t"
+                                   "add $1, %0"
+                                   : "=r" (dst)
+                                   : "r" (src));
+
+        asm ( "mov %1, %0\n\t"
+                  "add $1, %0"
+                  : "=r" (dst), "=r" (src)
+                  : [src] "r" (dst)
+                  : "r0");
+#if 0
+  L1: L2:
+        asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5"
+                           : /* No outputs. */
+                           : "r"(src), "r"(&dst)
+                           : "r5", "memory"
+                           : L1, L2 );
+#endif
         __complex__ c1;
         _Complex c2;
@@ -57 +105 @@
         return 0;
 }
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa gccExtensions.c" //
+// End: //