Changes in / [036dd5f:aeec6b7]

Files:

• Jenkins/FullBuild (modified) (1 diff)
• doc/LaTeXmacros/common.tex (modified) (2 diffs)
• doc/papers/general/.gitignore (modified) (1 diff)
• doc/papers/general/Paper.tex (modified) (5 diffs)
• doc/user/user.tex (modified) (44 diffs)
• src/Common/ScopedMap.h (modified) (18 diffs)
• src/Parser/TypedefTable.cc (modified) (1 diff)
• src/Parser/TypedefTable.h (modified) (1 diff)
• src/Parser/lex.ll (modified) (1 diff)
• src/prelude/Makefile.am (modified) (2 diffs)
• src/prelude/Makefile.in (modified) (2 diffs)
• src/prelude/prelude-gen.cc (modified) (12 diffs)
• src/tests/.expect/attributes.x86.txt (modified) (1 diff)
• src/tests/Makefile.am (modified) (1 diff)
• src/tests/attributes.c (modified) (2 diffs)

Jenkins/FullBuild

@@ -21 +21 @@
                                         gcc_5_x64: { trigger_build( 'gcc-5',   'x64', false ) },
                                         gcc_5_x86: { trigger_build( 'gcc-5',   'x86', false ) },
-                                        gcc_4_x64: { trigger_build( 'gcc-4.9', 'x64', false ) },
-                                        gcc_4_x86: { trigger_build( 'gcc-4.9', 'x86', false ) },
                                         clang_x64: { trigger_build( 'clang',   'x64', false ) },
                                         clang_x86: { trigger_build( 'clang',   'x86', false ) },

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Mon Mar 19 17:18:23 2018
-%% Update Count     : 379
+%% Last Modified On : Mon Jul  9 08:28:05 2018
+%% Update Count     : 380
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -55 +55 @@
 \setlength{\parindentlnth}{\parindent}
 
+\newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}}
 \newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}

doc/papers/general/.gitignore

@@ -4 +4 @@
 *.ps
 
-Paper.tex.plain
 mail
 Paper.out.ps

doc/papers/general/Paper.tex

@@ -226 +226 @@
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating-systems.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
-The TIOBE~\cite{TIOBE} ranks the top 5 most \emph{popular} programming languages as: Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.
+The TIOBE index~\cite{TIOBE} ranks the top 5 most \emph{popular} programming languages as: Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each, with a long tail.
 The top 3 rankings over the past 30 years are:
 \begin{center}
@@ -250 +250 @@
 (4) Extensions introduced by \CFA must be translated in the most efficient way possible.
 These goals ensure existing C code-bases can be converted to \CFA incrementally with minimal effort, and C programmers can productively generate \CFA code without training beyond the features being used.
-\CC is used similarly, but has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
+\CC is used similarly, but has the disadvantages of multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 
 All languages features discussed in this paper are working, except some advanced exception-handling features.
@@ -1096 +1096 @@
 
 
-\subsection{\texorpdfstring{\protect\lstinline{if} Statement}{if Statement}}
+\subsection{\texorpdfstring{\protect\lstinline@if@ Statement}{if Statement}}
 
 The @if@ expression allows declarations, similar to @for@ declaration expression:
@@ -1108 +1108 @@
 
 
-\subsection{\texorpdfstring{\protect\lstinline{switch} Statement}{switch Statement}}
+\subsection{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
 
 There are a number of deficiencies with the C @switch@ statements: enumerating @case@ lists, placement of @case@ clauses, scope of the switch body, and fall through between case clauses.
@@ -1263 +1263 @@
 
 
-\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
+\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
 
 While C provides @continue@ and @break@ statements for altering control flow, both are restricted to one level of nesting for a particular control structure.

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun May  6 10:33:53 2018
-%% Update Count     : 3319
+%% Last Modified On : Mon Jul  9 10:49:52 2018
+%% Update Count     : 3361
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -146 +146 @@
 \CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance.
 Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
-The primary new features include parametric-polymorphic routines and types, exceptions, concurrency, and modules.
+The primary new features include polymorphic routines and types, exceptions, concurrency, and modules.
 
 One of the main design philosophies of \CFA is to ``\Index{describe not prescribe}'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
@@ -155 +155 @@
 As well, new programs can be written in \CFA using a combination of C and \CFA features.
 
-\Index*[C++]{\CC{}} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
-However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, all of which requires significant effort and training to incrementally add \CC to a C-based project.
+\Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
+However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 In contrast, \CFA has 30 years of hindsight and a clean starting point.
 
 Like \Index*[C++]{\CC{}}, there may be both an old and new ways to achieve the same effect.
-For example, the following programs compare the \CFA, C, and \CC I/O mechanisms, where the programs output the same result.
-\begin{cquote}
+For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result.
+\begin{center}
 \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
 \multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
@@ -191 +191 @@
 \end{cfa}
 \end{tabular}
-\end{cquote}
+\end{center}
 While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
 
@@ -197 +197 @@
 
 This document is a programmer reference-manual for the \CFA programming language.
-The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
+The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of features.
 The manual does not teach programming, \ie how to combine the new constructs to build complex programs.
-A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
+The reader must have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
 Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 Changes to the syntax and additional features are expected to be included in later revisions.
@@ -206 +206 @@
 \section{Why fix C?}
 
-The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems (especially UNIX systems) to hobby projects.
+The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating-systems.
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
-The TIOBE index~\cite{TIOBE} for March 2016 showed the following programming-language popularity: \Index*{Java} 20.5\%, C 14.5\%, \Index*[C++]{\CC{}} 6.7\%, \Csharp 4.3\%, \Index*{Python} 4.3\%, where the next 50 languages are less than 3\% each with a long tail.
-As well, for 30 years, C has been the number 1 and 2 most popular programming language:
+The TIOBE index~\cite{TIOBE} for July 2018 ranks the top 5 most \emph{popular} programming languages as: \Index*{Java} 16\%, C 14\%, \Index*[C++]{\CC{}} 7.5\%, Python 6\%, Visual Basic 4\% = 47.5\%, where the next 50 languages are less than 4\% each, with a long tail.
+The top 3 rankings over the past 30 years are:
 \begin{center}
-\setlength{\tabcolsep}{1.5ex}
-\begin{tabular}{@{}r|c|c|c|c|c|c|c@{}}
-Ranking & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986          \\
-\hline
-Java    & 1             & 1             & 1             & 3             & 29    & -             & -                     \\
-\hline
-\R{C}   & \R{2} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1}         \\
-\hline
-\CC             & 3             & 3             & 3             & 2             & 2             & 2             & 7                     \\
+\setlength{\tabcolsep}{10pt}
+\begin{tabular}{@{}rccccccc@{}}
+                & 2018  & 2013  & 2008  & 2003  & 1998  & 1993  & 1988  \\ \hline
+Java    & 1             & 2             & 1             & 1             & 16    & -             & -             \\
+\R{C}   & \R{2} & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} \\
+\CC             & 3             & 4             & 3             & 3             & 2             & 2             & 5             \\
 \end{tabular}
 \end{center}
 Hence, C is still an extremely important programming language, with double the usage of \Index*[C++]{\CC{}}; in many cases, \CC is often used solely as a better C.
 Love it or hate it, C has been an important and influential part of computer science for 40 years and its appeal is not diminishing.
-Unfortunately, C has many problems and omissions that make it an unacceptable programming language for modern needs.
+Nevertheless, C has many problems and omissions that make it an unacceptable programming language for modern needs.
 
 As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
@@ -236 +233 @@
 These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection.
 As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
-These costs can be prohibitive for many companies with a large software-base in C/\CC, and a significant number of programmers require retraining to the new programming language.
-
-The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while containing modern language-features.
-Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
+These costs can be prohibitive for many companies with a large software-base in C/\CC, and a significant number of programmers require retraining in the new programming language.
+
+The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while adding modern language-features.
+To achieve these goals required a significant engineering exercise, where we had to ``think inside the existing C box''.
+Without these significant extension to C, it is unable to cope with the needs of modern programming problems and programmers;
 as a result, it will fade into disuse.
 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
@@ -255 +253 @@
 \begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
-int forty_two = identity( 42 );                 §\C{// T is bound to int, forty\_two == 42}§
+int forty_two = identity( 42 );                         §\C{// T is bound to int, forty\_two == 42}§
 \end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
@@ -307 +305 @@
 \begin{lstlisting}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
-int * ip = malloc();                                    §\C{// select type and size from left-hand side}§
+int * ip = malloc();                                            §\C{// select type and size from left-hand side}§
 double * dp = malloc();
 struct S {...} * sp = malloc();
@@ -318 +316 @@
 Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
 \begin{cfa}
-char abs( char );
-®extern "C" {® int abs( int ); ®}®              §\C{// use default C routine for int}§
-long int abs( long int );
-long long int abs( long long int );
-float abs( float );
-double abs( double );
-long double abs( long double );
-float _Complex abs( float _Complex );
-double _Complex abs( double _Complex );
-long double _Complex abs( long double _Complex );
+char ®abs®( char );
+extern "C" { int ®abs®( int ); }                        §\C{// use default C routine for int}§
+long int ®abs®( long int );
+long long int ®abs®( long long int );
+float ®abs®( float );
+double ®abs®( double );
+long double ®abs®( long double );
+float _Complex ®abs®( float _Complex );
+double _Complex ®abs®( double _Complex );
+long double _Complex ®abs®( long double _Complex );
 \end{cfa}
 The problem is the name clash between the library routine ©abs© and the \CFA names ©abs©.
 Hence, names appearing in an ©extern "C"© block have \newterm*{C linkage}.
 Then overloading polymorphism uses a mechanism called \newterm{name mangling}\index{mangling!name} to create unique names that are different from C names, which are not mangled.
-Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
-There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
+Hence, there is the same need, as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
+There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and types.
 
 This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
@@ -350 +348 @@
 \begin{description}
 \item
-\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}}
-The 1999 C standard plus GNU extensions.
+\Indexc{-std=gnu11}\index{compilation option!-std=gnu11@{©-std=gnu11©}}
+The 2011 C standard plus GNU extensions.
 \item
 \Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]@-fgnu89-inline@}}
-Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
+Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
 \end{description}
 The following new \CFA options are available:
@@ -427 +425 @@
 \begin{cfa}
 #ifndef __CFORALL__
-#include <stdio.h>§\indexc{stdio.h}§    §\C{// C header file}§
+#include <stdio.h>§\indexc{stdio.h}§            §\C{// C header file}§
 #else
-#include <fstream>§\indexc{fstream}§    §\C{// \CFA header file}§
+#include <fstream>§\indexc{fstream}§            §\C{// \CFA header file}§
 #endif
 \end{cfa}
@@ -435 +433 @@
 
 
+\section{Backquote Identifiers}
+\label{s:BackquoteIdentifiers}
+
+\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
+Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
+\begin{cfa}
+int ®`®otype®`® = 3;                                            §\C{// make keyword an identifier}§
+double ®`®forall®`® = 3.5;
+\end{cfa}
+
+Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
+\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
+Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
+
+\begin{figure}
+\begin{cfa}
+// include file uses the CFA keyword "with".
+#if ! defined( with )                                           §\C{// nesting ?}§
+#define with ®`®with®`®                                         §\C{// make keyword an identifier}§
+#define __CFA_BFD_H__
+#endif
+
+®#include_next <bfdlink.h>                                      §\C{// must have internal check for multiple expansion}§
+®
+#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
+#undef with
+#undef __CFA_BFD_H__
+#endif
+\end{cfa}
+\caption{Header-File Interposition}
+\label{f:HeaderFileInterposition}
+\end{figure}
+
+
 \section{Constant Underscores}
 
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
 \begin{cfa}
-2®_®147®_®483®_®648;                                    §\C{// decimal constant}§
-56®_®ul;                                                                §\C{// decimal unsigned long constant}§
-0®_®377;                                                                §\C{// octal constant}§
-0x®_®ff®_®ff;                                                   §\C{// hexadecimal constant}§
-0x®_®ef3d®_®aa5c;                                               §\C{// hexadecimal constant}§
-3.141®_®592®_®654;                                              §\C{// floating constant}§
-10®_®e®_®+1®_®00;                                               §\C{// floating constant}§
-0x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating}§
-0x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating long constant}§
+2®_®147®_®483®_®648;                                            §\C{// decimal constant}§
+56®_®ul;                                                                        §\C{// decimal unsigned long constant}§
+0®_®377;                                                                        §\C{// octal constant}§
+0x®_®ff®_®ff;                                                           §\C{// hexadecimal constant}§
+0x®_®ef3d®_®aa5c;                                                       §\C{// hexadecimal constant}§
+3.141®_®592®_®654;                                                      §\C{// floating constant}§
+10®_®e®_®+1®_®00;                                                       §\C{// floating constant}§
+0x®_®ff®_®ff®_®p®_®3;                                           §\C{// hexadecimal floating}§
+0x®_®1.ffff®_®ffff®_®p®_®128®_®l;                       §\C{// hexadecimal floating long constant}§
 L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
 \end{cfa}
@@ -469 +501 @@
 
 
-\section{Backquote Identifiers}
-\label{s:BackquoteIdentifiers}
-
-\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
-Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
-\begin{cfa}
-int ®`®otype®`® = 3;                    §\C{// make keyword an identifier}§
-double ®`®forall®`® = 3.5;
-\end{cfa}
-
-Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
-\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
-Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
-
-\begin{figure}
-\begin{cfa}
-// include file uses the CFA keyword "with".
-#if ! defined( with )                   §\C{// nesting ?}§
-#define with ®`®with®`®                 §\C{// make keyword an identifier}§
-#define __CFA_BFD_H__
-#endif
-
-®#include_next <bfdlink.h>              §\C{// must have internal check for multiple expansion}§
-®
-#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
-#undef with
-#undef __CFA_BFD_H__
-#endif
-\end{cfa}
-\caption{Header-File Interposition}
-\label{f:HeaderFileInterposition}
-\end{figure}
-
-
 \section{Exponentiation Operator}
 
@@ -518 +516 @@
 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
 \end{cfa}
-Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
+Parenthesis are necessary for the complex constants or the expression is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
 For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
@@ -524 +522 @@
 
 
-\section{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
+\section{Control Structures}
+
+\CFA identifies inconsistent, problematic, and missing control structures in C, and extends, modifies, and adds control structures to increase functionality and safety.
+
+
+%\subsection{\texorpdfstring{\protect\lstinline@if@ Statement}{if Statement}}
+\subsection{\texorpdfstring{\LstKeywordStyle{if} Statement}{if Statement}}
+
+The ©if© expression allows declarations, similar to ©for© declaration expression:
+\begin{cfa}
+if ( int x = f() ) ...                                          §\C{// x != 0}§
+if ( int x = f(), y = g() ) ...                         §\C{// x != 0 \&\& y != 0}§
+if ( int x = f(), y = g(); ®x < y® ) ...        §\C{// relational expression}§
+\end{cfa}
+Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if© expression, and the results are combined using the logical ©&&© operator.\footnote{\CC only provides a single declaration always compared not equal to 0.}
+The scope of the declaration(s) is local to the @if@ statement but exist within both the ``then'' and ``else'' clauses.
+
+
+%\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
+\subsection{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
+
+C allows a number of questionable forms for the ©switch© statement:
+\begin{enumerate}
+\item
+By default, the end of a ©case© clause\footnote{
+In this section, the term \emph{case clause} refers to either a ©case© or ©default© clause.}
+\emph{falls through} to the next ©case© clause in the ©switch© statement;
+to exit a ©switch© statement from a ©case© clause requires explicitly terminating the clause with a transfer statement, most commonly ©break©:
+\begin{cfa}
+switch ( i ) {
+  case 1:
+        ...
+        // fall-through
+  case 2:
+        ...
+        break;  // exit switch statement
+}
+\end{cfa}
+The ability to fall-through to the next clause \emph{is} a useful form of control flow, specifically when a sequence of case actions compound:
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
+\begin{cfa}
+switch ( argc ) {
+  case 3:
+        // open output file
+        // fall-through
+  case 2:
+        // open input file
+        break;  // exit switch statement
+  default:
+        // usage message
+}
+\end{cfa}
+&
+\begin{cfa}
+
+if ( argc == 3 ) {
+        // open output file
+        ®// open input file
+®} else if ( argc == 2 ) {
+        ®// open input file (duplicate)
+
+®} else {
+        // usage message
+}
+\end{cfa}
+\end{tabular}
+\end{cquote}
+In this example, case 2 is always done if case 3 is done.
+This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
+C also uses fall-through to handle multiple case-values resulting in the same action:
+\begin{cfa}
+switch ( i ) {
+  ®case 1: case 3: case 5:®     // odd values
+        // odd action
+        break;
+  ®case 2: case 4: case 6:®     // even values
+        // even action
+        break;
+}
+\end{cfa}
+However, this situation is handled in other languages without fall-through by allowing a list of case values.
+While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement.
+Hence, default fall-through semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
+
+\item
+It is possible to place ©case© clauses on statements nested \emph{within} the body of the ©switch© statement:
+\begin{cfa}
+switch ( i ) {
+  case 0:
+        if ( j < k ) {
+                ...
+          ®case 1:®             // transfer into "if" statement
+                ...
+        } // if
+  case 2:
+        while ( j < 5 ) {
+                ...
+          ®case 3:®             // transfer into "while" statement
+                ...
+        } // while
+} // switch
+\end{cfa}
+The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
+The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
+The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
+There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
+Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
+\begin{cfa}
+register int n = (count + 7) / 8;
+switch ( count % 8 ) {
+case 0: do{ *to = *from++;
+case 7:         *to = *from++;
+case 6:         *to = *from++;
+case 5:         *to = *from++;
+case 4:         *to = *from++;
+case 3:         *to = *from++;
+case 2:         *to = *from++;
+case 1:         *to = *from++;
+                } while ( --n > 0 );
+}
+\end{cfa}
+which unrolls a loop N times (N = 8 above) and uses the ©switch© statement to deal with any iterations not a multiple of N.
+While efficient, this sort of special purpose usage is questionable:
+\begin{quote}
+Disgusting, no? But it compiles and runs just fine. I feel a combination of pride and revulsion at this
+discovery.~\cite{Duff83}
+\end{quote}
+\item
+It is possible to place the ©default© clause anywhere in the list of labelled clauses for a ©switch© statement, rather than only at the end.
+Virtually all programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.
+The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected;
+hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics.
+This physical placement can be compared to the physical placement of an ©else© clause at the end of a series of connected ©if©/©else© statements.
+
+\item
+It is possible to place unreachable code at the start of a ©switch© statement, as in:
+\begin{cfa}
+switch ( x ) {
+        ®int y = 1;®                                                    §\C{// unreachable initialization}§
+        ®x = 7;®                                                                §\C{// unreachable code without label/branch}§
+  case 0: ...
+        ...
+        ®int z = 0;®                                                    §\C{// unreachable initialization, cannot appear after case}§
+        z = 2;
+  case 1:
+        ®x = z;®                                                                §\C{// without fall through, z is uninitialized}§
+}
+\end{cfa}
+While the declaration of the local variable ©y© is useful with a scope across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
+Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, both of which are problematic.
+As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
+The key observation is that the ©switch© statement branches into control structure, \ie there are multiple entry points into its statement body.
+\end{enumerate}
+
+Before discussing potential language changes to deal with these problems, it is worth observing that in a typical C program:
+\begin{itemize}
+\item
+the number of ©switch© statements is small,
+\item
+most ©switch© statements are well formed (\ie no \Index*{Duff's device}),
+\item
+the ©default© clause is usually written as the last case-clause,
+\item
+and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
+\end{itemize}
+These observations put into perspective the \CFA changes to the ©switch©.
+\begin{enumerate}
+\item
+Eliminating default fall-through has the greatest potential for affecting existing code.
+However, even if fall-through is removed, most ©switch© statements would continue to work because of the explicit transfers already present at the end of each ©case© clause, the common placement of the ©default© clause at the end of the case list, and the most common use of fall-through, \ie a list of ©case© clauses executing common code, \eg:
+\begin{cfa}
+case 1:  case 2:  case 3: ...
+\end{cfa}
+still works.
+Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
+Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
+\begin{cfa}
+®choose® ( i ) {
+  case 1:  case 2:  case 3:
+        ...
+        ®// implicit end of switch (break)
+  ®case 5:
+        ...
+        ®fallthru®;                                                             §\C{// explicit fall through}§
+  case 7:
+        ...
+        ®break®                                                                 §\C{// explicit end of switch (redundant)}§
+  default:
+        j = 3;
+}
+\end{cfa}
+Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
+An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
+An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
+As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
+\item
+\Index*{Duff's device} is eliminated from both ©switch© and ©choose© statements, and only invalidates a small amount of very questionable code.
+Hence, the ©case© clause must appear at the same nesting level as the ©switch©/©choose© body, as is done in most other programming languages with ©switch© statements.
+\item
+The issue of ©default© at locations other than at the end of the cause clause can be solved by using good programming style, and there are a few reasonable situations involving fall-through where the ©default© clause needs to appear is locations other than at the end.
+Therefore, no change is made for this issue.
+\item
+Dealing with unreachable code in a ©switch©/©choose© body is solved by restricting declarations and associated initialization to the start of statement body, which is executed \emph{before} the transfer to the appropriate ©case© clause\footnote{
+Essentially, these declarations are hoisted before the ©switch©/©choose© statement and both declarations and statement are surrounded by a compound statement.} and precluding statements before the first ©case© clause.
+Further declarations at the same nesting level as the statement body are disallowed to ensure every transfer into the body is sound.
+\begin{cfa}
+switch ( x ) {
+        ®int i = 0;®                                                    §\C{// allowed only at start}§
+  case 0:
+        ...
+        ®int j = 0;®                                                    §\C{// disallowed}§
+  case 1:
+        {
+                ®int k = 0;®                                            §\C{// allowed at different nesting levels}§
+                ...
+          ®case 2:®                                                             §\C{// disallow case in nested statements}§
+        }
+  ...
+}
+\end{cfa}
+\end{enumerate}
+
+
+%\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
+\subsection{\texorpdfstring{\LstKeywordStyle{case} Statement}{case Statement}}
+
+C restricts the ©case© clause of a ©switch© statement to a single value.
+For multiple ©case© clauses associated with the same statement, it is necessary to have multiple ©case© clauses rather than multiple values.
+Requiring a ©case© clause for each value does not seem to be in the spirit of brevity normally associated with C.
+Therefore, the ©case© clause is extended with a list of values, as in:
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{cfa}
+switch ( i ) {
+  case ®1, 3, 5®:
+        ...
+  case ®2, 4, 6®:
+        ...
+}
+\end{cfa}
+&
+\begin{cfa}
+switch ( i ) {
+  case 1: case 3 : case 5:
+        ...
+  case 2: case 4 : case 6:
+        ...
+}
+\end{cfa}
+&
+\begin{cfa}
+
+// odd values
+
+// even values
+
+
+\end{cfa}
+\end{tabular}
+\end{cquote}
+In addition, subranges are allowed to specify case values.\footnote{
+gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
+\begin{cfa}
+switch ( i ) {
+  case ®1~5:®                                   §\C{// 1, 2, 3, 4, 5}§
+        ...
+  case ®10~15:®                                 §\C{// 10, 11, 12, 13, 14, 15}§
+        ...
+}
+\end{cfa}
+Lists of subranges are also allowed.
+\begin{cfa}
+case ®1~5, 12~21, 35~42®:
+\end{cfa}
+
+
+%\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
+\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
@@ -626 +903 @@
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
 Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
-The implicit targets of the current ©continue© and ©break©, \ie the closest enclosing loop or ©switch©, change as certain constructs are added or removed.
-
-
-\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
-
-C allows a number of questionable forms for the ©switch© statement:
-\begin{enumerate}
-\item
-By default, the end of a ©case© clause\footnote{
-In this section, the term \emph{case clause} refers to either a ©case© or ©default© clause.}
-\emph{falls through} to the next ©case© clause in the ©switch© statement;
-to exit a ©switch© statement from a ©case© clause requires explicitly terminating the clause with a transfer statement, most commonly ©break©:
-\begin{cfa}
-switch ( i ) {
-  case 1:
-        ...
-        // fall-through
-  case 2:
-        ...
-        break;  // exit switch statement
-}
-\end{cfa}
-The ability to fall-through to the next clause \emph{is} a useful form of control flow, specifically when a sequence of case actions compound:
-\begin{cquote}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\begin{cfa}
-switch ( argc ) {
-  case 3:
-        // open output file
-        // fall-through
-  case 2:
-        // open input file
-        break;  // exit switch statement
-  default:
-        // usage message
-}
-\end{cfa}
-&
-\begin{cfa}
-
-if ( argc == 3 ) {
-        // open output file
-        ®// open input file
-®} else if ( argc == 2 ) {
-        ®// open input file (duplicate)
-
-®} else {
-        // usage message
-}
-\end{cfa}
-\end{tabular}
-\end{cquote}
-In this example, case 2 is always done if case 3 is done.
-This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
-C also uses fall-through to handle multiple case-values resulting in the same action:
-\begin{cfa}
-switch ( i ) {
-  ®case 1: case 3: case 5:®     // odd values
-        // odd action
-        break;
-  ®case 2: case 4: case 6:®     // even values
-        // even action
-        break;
-}
-\end{cfa}
-However, this situation is handled in other languages without fall-through by allowing a list of case values.
-While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from virtually all other programming languages with a ©switch© statement.
-Hence, default fall-through semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
-
-\item
-It is possible to place ©case© clauses on statements nested \emph{within} the body of the ©switch© statement:
-\begin{cfa}
-switch ( i ) {
-  case 0:
-        if ( j < k ) {
-                ...
-          ®case 1:®             // transfer into "if" statement
-                ...
-        } // if
-  case 2:
-        while ( j < 5 ) {
-                ...
-          ®case 3:®             // transfer into "while" statement
-                ...
-        } // while
-} // switch
-\end{cfa}
-The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
-The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
-The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
-There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
-Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
-\begin{cfa}
-register int n = (count + 7) / 8;
-switch ( count % 8 ) {
-case 0: do{ *to = *from++;
-case 7:         *to = *from++;
-case 6:         *to = *from++;
-case 5:         *to = *from++;
-case 4:         *to = *from++;
-case 3:         *to = *from++;
-case 2:         *to = *from++;
-case 1:         *to = *from++;
-                } while ( --n > 0 );
-}
-\end{cfa}
-which unrolls a loop N times (N = 8 above) and uses the ©switch© statement to deal with any iterations not a multiple of N.
-While efficient, this sort of special purpose usage is questionable:
-\begin{quote}
-Disgusting, no? But it compiles and runs just fine. I feel a combination of pride and revulsion at this
-discovery.~\cite{Duff83}
-\end{quote}
-\item
-It is possible to place the ©default© clause anywhere in the list of labelled clauses for a ©switch© statement, rather than only at the end.
-Virtually all programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.
-The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected;
-hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics.
-This physical placement can be compared to the physical placement of an ©else© clause at the end of a series of connected ©if©/©else© statements.
-
-\item
-It is possible to place unreachable code at the start of a ©switch© statement, as in:
-\begin{cfa}
-switch ( x ) {
-        ®int y = 1;®                            §\C{// unreachable initialization}§
-        ®x = 7;®                                        §\C{// unreachable code without label/branch}§
-  case 0: ...
-        ...
-        ®int z = 0;®                            §\C{// unreachable initialization, cannot appear after case}§
-        z = 2;
-  case 1:
-        ®x = z;®                                        §\C{// without fall through, z is uninitialized}§
-}
-\end{cfa}
-While the declaration of the local variable ©y© is useful with a scope across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
-Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, both of which are problematic.
-As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
-The key observation is that the ©switch© statement branches into control structure, \ie there are multiple entry points into its statement body.
-\end{enumerate}
-
-Before discussing potential language changes to deal with these problems, it is worth observing that in a typical C program:
-\begin{itemize}
-\item
-the number of ©switch© statements is small,
-\item
-most ©switch© statements are well formed (\ie no \Index*{Duff's device}),
-\item
-the ©default© clause is usually written as the last case-clause,
-\item
-and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
-\end{itemize}
-These observations put into perspective the \CFA changes to the ©switch©.
-\begin{enumerate}
-\item
-Eliminating default fall-through has the greatest potential for affecting existing code.
-However, even if fall-through is removed, most ©switch© statements would continue to work because of the explicit transfers already present at the end of each ©case© clause, the common placement of the ©default© clause at the end of the case list, and the most common use of fall-through, \ie a list of ©case© clauses executing common code, \eg:
-\begin{cfa}
-case 1:  case 2:  case 3: ...
-\end{cfa}
-still works.
-Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
-Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
-\begin{cfa}
-®choose® ( i ) {
-  case 1:  case 2:  case 3:
-        ...
-        ®// implicit end of switch (break)
-  ®case 5:
-        ...
-        ®fallthru®;                                     §\C{// explicit fall through}§
-  case 7:
-        ...
-        ®break®                                         §\C{// explicit end of switch (redundant)}§
-  default:
-        j = 3;
-}
-\end{cfa}
-Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
-An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
-An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
-As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
-\item
-\Index*{Duff's device} is eliminated from both ©switch© and ©choose© statements, and only invalidates a small amount of very questionable code.
-Hence, the ©case© clause must appear at the same nesting level as the ©switch©/©choose© body, as is done in most other programming languages with ©switch© statements.
-\item
-The issue of ©default© at locations other than at the end of the cause clause can be solved by using good programming style, and there are a few reasonable situations involving fall-through where the ©default© clause needs to appear is locations other than at the end.
-Therefore, no change is made for this issue.
-\item
-Dealing with unreachable code in a ©switch©/©choose© body is solved by restricting declarations and associated initialization to the start of statement body, which is executed \emph{before} the transfer to the appropriate ©case© clause\footnote{
-Essentially, these declarations are hoisted before the ©switch©/©choose© statement and both declarations and statement are surrounded by a compound statement.} and precluding statements before the first ©case© clause.
-Further declarations at the same nesting level as the statement body are disallowed to ensure every transfer into the body is sound.
-\begin{cfa}
-switch ( x ) {
-        ®int i = 0;®                            §\C{// allowed only at start}§
-  case 0:
-        ...
-        ®int j = 0;®                            §\C{// disallowed}§
-  case 1:
-        {
-                ®int k = 0;®                    §\C{// allowed at different nesting levels}§
-                ...
-          ®case 2:®                                     §\C{// disallow case in nested statements}§
-        }
-  ...
-}
-\end{cfa}
-\end{enumerate}
-
-
-\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
-
-C restricts the ©case© clause of a ©switch© statement to a single value.
-For multiple ©case© clauses associated with the same statement, it is necessary to have multiple ©case© clauses rather than multiple values.
-Requiring a ©case© clause for each value does not seem to be in the spirit of brevity normally associated with C.
-Therefore, the ©case© clause is extended with a list of values, as in:
-\begin{cquote}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
-\begin{cfa}
-switch ( i ) {
-  case ®1, 3, 5®:
-        ...
-  case ®2, 4, 6®:
-        ...
-}
-\end{cfa}
-&
-\begin{cfa}
-switch ( i ) {
-  case 1: case 3 : case 5:
-        ...
-  case 2: case 4 : case 6:
-        ...
-}
-\end{cfa}
-&
-\begin{cfa}
-
-// odd values
-
-// even values
-
-
-\end{cfa}
-\end{tabular}
-\end{cquote}
-In addition, subranges are allowed to specify case values.\footnote{
-gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
-\begin{cfa}
-switch ( i ) {
-  case ®1~5:®                                   §\C{// 1, 2, 3, 4, 5}§
-        ...
-  case ®10~15:®                                 §\C{// 10, 11, 12, 13, 14, 15}§
-        ...
-}
-\end{cfa}
-Lists of subranges are also allowed.
-\begin{cfa}
-case ®1~5, 12~21, 35~42®:
-\end{cfa}
-
-
-\section{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+Otherwise, the implicit targets of the current ©continue© and ©break©, \ie the closest enclosing loop or ©switch©, change as certain constructs are added or removed.
+
+
+%\section{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+\section{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
 \label{s:WithStatement}
 
@@ -902 +922 @@
 \begin{cfa}
 void f( S s ) {
-        `s.`c; `s.`i; `s.`d;                                    §\C{// access containing fields}§
+        ®s.®c; ®s.®i; ®s.®d;                                    §\C{// access containing fields}§
 }
 \end{cfa}
@@ -913 +933 @@
         double d;
         void f() {                                                              §\C{// implicit ``this'' aggregate}§
-                `this->`c; `this->`i; `this->`d;        §\C{// access containing fields}§
+                ®this->®c; ®this->®i; ®this->®d;        §\C{// access containing fields}§
         }
 }
 \end{C++}
-Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]$this->$ because of lexical scoping.
+Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
 However, for other aggregate parameters, qualification is necessary:
 \begin{cfa}
@@ -923 +943 @@
 int S::f( T & t ) {                                                     §\C{// multiple aggregate parameters}§
         c; i; d;                                                                §\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}§
-        `t.`m; `t.`n;                                                   §\C{// must qualify}§
-}
-\end{cfa}
-
-To simplify the programmer experience, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
+        ®t.®m; ®t.®n;                                                   §\C{// must qualify}§
+}
+\end{cfa}
+
+To simplify the programmer experience, \CFA provides a ©with© statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
 Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
 \begin{cfa}
-void f( S & this ) `with ( this )` {            §\C{// with statement}§
+void f( S & this ) ®with ( this )® {            §\C{// with statement}§
         c; i; d;                                                                §\C{\color{red}// this.c, this.i, this.d}§
 }
@@ -936 +956 @@
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
-void f( S & s, T & t ) `with ( s, t )` {                §\C{// multiple aggregate parameters}§
+void f( S & s, T & t ) ®with ( s, t )® {        §\C{// multiple aggregate parameters}§
         c; i; d;                                                                §\C{\color{red}// s.c, s.i, s.d}§
         m; n;                                                                   §\C{\color{red}// t.m, t.n}§
@@ -942 +962 @@
 \end{cfa}
 
-In detail, the @with@ statement has the form:
+In detail, the ©with© statement has the form:
 \begin{cfa}
 §\emph{with-statement}§:
@@ -957 +977 @@
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
-struct S { int `i`; int j; double m; } s, w;
-struct T { int `i`; int k; int m; } t, w;
+struct S { int ®i®; int j; double m; } s, w;
+struct T { int ®i®; int k; int m; } t, w;
 with ( s, t ) {
         j + k;                                                                  §\C{// unambiguous, s.j + t.k}§
@@ -969 +989 @@
 }
 \end{cfa}
-For parallel semantics, both @s.i@ and @t.i@ are visible, so @i@ is ambiguous without qualification;
-for nested semantics, @t.i@ hides @s.i@, so @i@ implies @t.i@.
+For parallel semantics, both ©s.i© and ©t.i© are visible, so ©i© is ambiguous without qualification;
+for nested semantics, ©t.i© hides ©s.i©, so ©i© implies ©t.i©.
 \CFA's ability to overload variables means fields with the same name but different types are automatically disambiguated, eliminating most qualification when opening multiple aggregates.
 Qualification or a cast is used to disambiguate.
 
-There is an interesting problem between parameters and the function-body @with@, \eg:
+There is an interesting problem between parameters and the function-body ©with©, \eg:
 \begin{cfa}
 void ?{}( S & s, int i ) with ( s ) {           §\C{// constructor}§
-        `s.i = i;`  j = 3;  m = 5.5;                    §\C{// initialize fields}§
-}
-\end{cfa}
-Here, the assignment @s.i = i@ means @s.i = s.i@, which is meaningless, and there is no mechanism to qualify the parameter @i@, making the assignment impossible using the function-body @with@.
+        ®s.i = i;®  j = 3;  m = 5.5;                    §\C{// initialize fields}§
+}
+\end{cfa}
+Here, the assignment ©s.i = i© means ©s.i = s.i©, which is meaningless, and there is no mechanism to qualify the parameter ©i©, making the assignment impossible using the function-body ©with©.
 To solve this problem, parameters are treated like an initialized aggregate:
 \begin{cfa}
@@ -990 +1010 @@
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
-void ?{}( S & s, int `i` ) with ( s ) `with( §\emph{\color{red}params}§ )` {
-        s.i = `i`; j = 3; m = 5.5;
-}
-\end{cfa}
-Finally, a cast may be used to disambiguate among overload variables in a @with@ expression:
+void ?{}( S & s, int ®i® ) with ( s ) ®with( §\emph{\color{red}params}§ )® {
+        s.i = ®i®; j = 3; m = 5.5;
+}
+\end{cfa}
+Finally, a cast may be used to disambiguate among overload variables in a ©with© expression:
 \begin{cfa}
 with ( w ) { ... }                                                      §\C{// ambiguous, same name and no context}§
 with ( (S)w ) { ... }                                           §\C{// unambiguous, cast}§
 \end{cfa}
-and @with@ expressions may be complex expressions with type reference (see Section~\ref{s:References}) to aggregate:
+and ©with© expressions may be complex expressions with type reference (see Section~\ref{s:References}) to aggregate:
 % \begin{cfa}
 % struct S { int i, j; } sv;
@@ -1019 +1039 @@
 class C {
         int i, j;
-        int mem() {                                     §\C{\color{red}// implicit "this" parameter}§
-                i = 1;                                  §\C{\color{red}// this->i}§
-                j = 2;                                  §\C{\color{red}// this->j}§
+        int mem() {                                                             §\C{\color{red}// implicit "this" parameter}§
+                i = 1;                                                          §\C{\color{red}// this->i}§
+                j = 2;                                                          §\C{\color{red}// this->j}§
         }
 }
@@ -1028 +1048 @@
 \begin{cfa}
 struct S { int i, j; };
-int mem( S & ®this® ) {                 §\C{// explicit "this" parameter}§
-        ®this.®i = 1;                           §\C{// "this" is not elided}§
+int mem( S & ®this® ) {                                         §\C{// explicit "this" parameter}§
+        ®this.®i = 1;                                                   §\C{// "this" is not elided}§
         ®this.®j = 2;
 }
@@ -1037 +1057 @@
 \CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
 \begin{cfa}
-int mem( S & this ) ®with( this )® { §\C{// with clause}§
-        i = 1;                                          §\C{\color{red}// this.i}§
-        j = 2;                                          §\C{\color{red}// this.j}§
+int mem( S & this ) ®with( this )® {            §\C{// with clause}§
+        i = 1;                                                                  §\C{\color{red}// this.i}§
+        j = 2;                                                                  §\C{\color{red}// this.j}§
 }
 \end{cfa}
@@ -1056 +1076 @@
         struct S1 { ... } s1;
         struct S2 { ... } s2;
-        ®with( s1 )® {                          §\C{// with statement}§
+        ®with( s1 )® {                                                  §\C{// with statement}§
                 // access fields of s1 without qualification
-                ®with s2® {                             §\C{// nesting}§
+                ®with s2® {                                                     §\C{// nesting}§
                         // access fields of s1 and s2 without qualification
                 }
@@ -1113 +1133 @@
 Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise.
 \begin{cfa}
-exception_t E {};                               §\C{// exception type}§
+exception_t E {};                                                       §\C{// exception type}§
 void f(...) {
-        ... throw E{}; ...                      §\C{// termination}§
-        ... throwResume E{}; ...        §\C{// resumption}§
+        ... throw E{}; ...                                              §\C{// termination}§
+        ... throwResume E{}; ...                                §\C{// resumption}§
 }
 try {
         f(...);
-} catch( E e ; §boolean-predicate§ ) {                  §\C[8cm]{// termination handler}§
+} catch( E e ; §boolean-predicate§ ) {          §\C[8cm]{// termination handler}§
         // recover and continue
-} catchResume( E e ; §boolean-predicate§ ) {    §\C{// resumption handler}\CRT§
+} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}\CRT§
         // repair and return
 } finally {
@@ -1642 +1662 @@
 \begin{itemize}
 \item
-if ©R© is an \Index{rvalue} of type ©T &$_1$...&$_r$© where $r \ge 1$ references (©&© symbols) then ©&R© has type ©T ®*®&$_{\color{red}2}$...&$_{\color{red}r}$©, \ie ©T© pointer with $r-1$ references (©&© symbols).
-
-\item
-if ©L© is an \Index{lvalue} of type ©T &$_1$...&$_l$© where $l \ge 0$ references (©&© symbols) then ©&L© has type ©T ®*®&$_{\color{red}1}$...&$_{\color{red}l}$©, \ie ©T© pointer with $l$ references (©&© symbols).
+if ©R© is an \Index{rvalue} of type ©T &©$_1\cdots$ ©&©$_r$, where $r \ge 1$ references (©&© symbols), than ©&R© has type ©T ®*®&©$_{\color{red}2}\cdots$ ©&©$_{\color{red}r}$, \ie ©T© pointer with $r-1$ references (©&© symbols).
+
+\item
+if ©L© is an \Index{lvalue} of type ©T &©$_1\cdots$ ©&©$_l$, where $l \ge 0$ references (©&© symbols), than ©&L© has type ©T ®*®&©$_{\color{red}1}\cdots$ ©&©$_{\color{red}l}$, \ie ©T© pointer with $l$ references (©&© symbols).
 \end{itemize}
 The following example shows the first rule applied to different \Index{rvalue} contexts:
@@ -5999 +6019 @@
 
 
-\subsection{Conversion}
+\subsection{String to Value Conversion}
 
 \leavevmode
@@ -6069 +6089 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-void rand48seed( long int s );§\indexc{rand48seed}§
-char rand48();§\indexc{rand48}§
-int rand48();
-unsigned int rand48();
-long int rand48();
-unsigned long int rand48();
-float rand48();
-double rand48();
-float _Complex rand48();
-double _Complex rand48();
-long double _Complex rand48();
+void srandom( unsigned int seed );§\indexc{srandom}§
+char random( void );§\indexc{random}§
+char random( char u );                                          §\C{// [0,u)}§
+char random( char l, char u );                          §\C{// [l,u)}§
+int random( void );
+int random( int u );                                            §\C{// [0,u)}§
+int random( int l, int u );                                     §\C{// [l,u)}§
+unsigned int random( void );
+unsigned int random( unsigned int u );          §\C{// [0,u)}§
+unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u)}§
+long int random( void );
+long int random( long int u );                          §\C{// [0,u)}§
+long int random( long int l, long int u );      §\C{// [l,u)}§
+unsigned long int random( void );
+unsigned long int random( unsigned long int u ); §\C{// [0,u)}§
+unsigned long int random( unsigned long int l, unsigned long int u ); §\C{// [l,u)}§
+float random( void );                                            §\C{// [0.0, 1.0)}§
+double random( void );                                           §\C{// [0.0, 1.0)}§
+float _Complex random( void );                           §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
+double _Complex random( void );                          §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
+long double _Complex random( void );             §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
 \end{cfa}
 
@@ -6458 +6488 @@
 
 
-\section{Time}
-\label{s:TimeLib}
+\section{Time Keeping}
+\label{s:TimeKeeping}
 
 
 %\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
-\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{Duration}}}{Duration}}
+\subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}}
 \label{s:Duration}
 
@@ -6512 +6542 @@
 
 Duration abs( Duration rhs );
-
-forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
 
 Duration ?`ns( int64_t nsec );
@@ -6537 +6565 @@
 int64_t ?`d( Duration dur );
 int64_t ?`w( Duration dur );
+
+Duration max( Duration lhs, Duration rhs );
+Duration min( Duration lhs, Duration rhs );
 \end{cfa}
 
 
 %\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
-\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{timeval}}}{timeval}}
+\subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}}
 \label{s:timeval}
 
@@ -6560 +6591 @@
 
 
-\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+%\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+\subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}}
 \label{s:timespec}
 
@@ -6579 +6611 @@
 
 
-\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+%\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+\subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}}
 \label{s:itimerval}
 
@@ -6589 +6622 @@
 
 
-\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+%\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+\subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}}
 \label{s:Time}
 
@@ -6600 +6634 @@
 void ?{}( Time & time );
 void ?{}( Time & time, zero_t );
-void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
+
 Time ?=?( Time & time, zero_t );
 
@@ -6609 +6643 @@
 Time ?=?( Time & time, timespec t );
 
-Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
-Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
-Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
-
-Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
-Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
-Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-_Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
-_Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
-_Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
-_Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
-_Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
-_Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
-
-forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+Time ?+?( Time & lhs, Duration rhs );
+Time ?+?( Duration lhs, Time rhs );
+Time ?+=?( Time & lhs, Duration rhs );
+
+Duration ?-?( Time lhs, Time rhs );
+Time ?-?( Time lhs, Duration rhs );
+Time ?-=?( Time & lhs, Duration rhs );
+_Bool ?==?( Time lhs, Time rhs );
+_Bool ?!=?( Time lhs, Time rhs );
+_Bool ?<?( Time lhs, Time rhs );
+_Bool ?<=?( Time lhs, Time rhs );
+_Bool ?>?( Time lhs, Time rhs );
+_Bool ?>=?( Time lhs, Time rhs );
 
 char * yy_mm_dd( Time time, char * buf );
@@ -6641 +6673 @@
 
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
 \end{cfa}
 
@@ -6661 +6694 @@
 
 %\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
-\subsection{\texorpdfstring{\LstKeywordStyle{\textmd{Clock}}}{Clock}}
+\subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}}
 \label{s:Clock}
 
@@ -6675 +6708 @@
 void ?{}( Clock & clk );
 void ?{}( Clock & clk, Duration adj );
-Duration getRes();
+
+Duration getResNsec();                                  §\C{// with nanoseconds}§
+Duration getRes();                                              §\C{// without nanoseconds}§
+
 Time getTimeNsec();                                             §\C{// with nanoseconds}§
 Time getTime();                                                 §\C{// without nanoseconds}§

src/Common/ScopedMap.h

@@ -22 +22 @@
 #include <vector>
 
+/// Default (empty) ScopedMap note type
+struct EmptyNote {};
+
 /// A map where the items are placed into nested scopes;
-/// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward
-template<typename Key, typename Value>
+/// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward.
+/// Scopes may be annotated with a value; the annotation defaults to empty
+template<typename Key, typename Value, typename Note = EmptyNote>
 class ScopedMap {
-        typedef std::map< Key, Value > Scope;
+        typedef std::map< Key, Value > MapType;
+        struct Scope {
+                MapType map;
+                Note note;
+
+                template<typename N>
+                Scope(N&& n) : map(), note(std::forward<N>(n)) {}
+                
+                Scope() = default;
+                Scope(const Scope&) = default;
+                Scope(Scope&&) = default;
+                Scope& operator= (const Scope&) = default;
+                Scope& operator= (Scope&&) = default;
+        };
         typedef std::vector< Scope > ScopeList;
 
         ScopeList scopes; ///< scoped list of maps
 public:
-        typedef typename Scope::key_type key_type;
-        typedef typename Scope::mapped_type mapped_type;
-        typedef typename Scope::value_type value_type;
+        typedef typename MapType::key_type key_type;
+        typedef typename MapType::mapped_type mapped_type;
+        typedef typename MapType::value_type value_type;
         typedef typename ScopeList::size_type size_type;
         typedef typename ScopeList::difference_type difference_type;
-        typedef typename Scope::reference reference;
-        typedef typename Scope::const_reference const_reference;
-        typedef typename Scope::pointer pointer;
-        typedef typename Scope::const_pointer const_pointer;
+        typedef typename MapType::reference reference;
+        typedef typename MapType::const_reference const_reference;
+        typedef typename MapType::pointer pointer;
+        typedef typename MapType::const_pointer const_pointer;
 
         class iterator : public std::iterator< std::bidirectional_iterator_tag,
@@ -45 +62 @@
         friend class ScopedMap;
         friend class const_iterator;
-                typedef typename std::map< Key, Value >::iterator wrapped_iterator;
-                typedef typename std::vector< std::map< Key, Value > > scope_list;
+                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+                typedef typename ScopedMap::ScopeList scope_list;
                 typedef typename scope_list::size_type size_type;
 
                 /// Checks if this iterator points to a valid item
                 bool is_valid() const {
-                        return it != (*scopes)[level].end();
+                        return it != (*scopes)[level].map.end();
                 }
 
@@ -79 +96 @@
 
                 iterator& operator++ () {
-                        if ( it == (*scopes)[level].end() ) {
+                        if ( it == (*scopes)[level].map.end() ) {
                                 if ( level == 0 ) return *this;
                                 --level;
-                                it = (*scopes)[level].begin();
+                                it = (*scopes)[level].map.begin();
                         } else {
                                 ++it;
@@ -92 +109 @@
                 iterator& operator-- () {
                         // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].begin() ) {
+                        if ( it == (*scopes)[level].map.begin() ) {
                                 ++level;
-                                it = (*scopes)[level].end();
+                                it = (*scopes)[level].map.end();
                         }
                         --it;
@@ -107 +124 @@
 
                 size_type get_level() const { return level; }
+
+                Note& get_note() { return (*scopes)[level].note; }
+                const Note& get_note() const { return (*scopes)[level].note; }
 
         private:
@@ -117 +137 @@
                                                      value_type > {
         friend class ScopedMap;
-                typedef typename std::map< Key, Value >::iterator wrapped_iterator;
-                typedef typename std::map< Key, Value >::const_iterator wrapped_const_iterator;
-                typedef typename std::vector< std::map< Key, Value > > scope_list;
+                typedef typename ScopedMap::MapType::iterator wrapped_iterator;
+                typedef typename ScopedMap::MapType::const_iterator wrapped_const_iterator;
+                typedef typename ScopedMap::ScopeList scope_list;
                 typedef typename scope_list::size_type size_type;
 
                 /// Checks if this iterator points to a valid item
                 bool is_valid() const {
-                        return it != (*scopes)[level].end();
+                        return it != (*scopes)[level].map.end();
                 }
 
@@ -157 +177 @@
 
                 const_iterator& operator++ () {
-                        if ( it == (*scopes)[level].end() ) {
+                        if ( it == (*scopes)[level].map.end() ) {
                                 if ( level == 0 ) return *this;
                                 --level;
-                                it = (*scopes)[level].begin();
+                                it = (*scopes)[level].map.begin();
                         } else {
                                 ++it;
@@ -170 +190 @@
                 const_iterator& operator-- () {
                         // may fail if this is the begin iterator; allowed by STL spec
-                        if ( it == (*scopes)[level].begin() ) {
+                        if ( it == (*scopes)[level].map.begin() ) {
                                 ++level;
-                                it = (*scopes)[level].end();
+                                it = (*scopes)[level].map.end();
                         }
                         --it;
@@ -185 +205 @@
 
                 size_type get_level() const { return level; }
+
+                const Note& get_note() const { return (*scopes)[level].note; }
 
         private:
@@ -197 +219 @@
         }
 
+        // Starts a new scope with the given note
+        template<typename N>
+        void beginScope( N&& n ) {
+                scopes.emplace_back( std::forward<N>(n) );
+        }
+
         /// Ends a scope; invalidates any iterators pointing to elements of that scope
         void endScope() {
@@ -204 +232 @@
 
         /// Default constructor initializes with one scope
-        ScopedMap() { beginScope(); }
-
-        iterator begin() { return iterator(scopes, scopes.back().begin(), currentScope()).next_valid(); }
-        const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), currentScope()).next_valid(); }
-        const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), currentScope()).next_valid(); }
-        iterator end() { return iterator(scopes, scopes[0].end(), 0); }
-        const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }
-        const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); }
+        ScopedMap() : scopes() { beginScope(); }
+
+        /// Constructs with a given note on the outermost scope
+        template<typename N>
+        ScopedMap( N&& n ) : scopes() { beginScope(std::forward<N>(n)); }
+
+        iterator begin() { return iterator(scopes, scopes.back().map.begin(), currentScope()).next_valid(); }
+        const_iterator begin() const { return const_iterator(scopes, scopes.back().map.begin(), currentScope()).next_valid(); }
+        const_iterator cbegin() const { return const_iterator(scopes, scopes.back().map.begin(), currentScope()).next_valid(); }
+        iterator end() { return iterator(scopes, scopes[0].map.end(), 0); }
+        const_iterator end() const { return const_iterator(scopes, scopes[0].map.end(), 0); }
+        const_iterator cend() const { return const_iterator(scopes, scopes[0].map.end(), 0); }
 
         /// Gets the index of the current scope (counted from 1)
         size_type currentScope() const { return scopes.size() - 1; }
+
+        /// Gets the note at the given scope
+        Note& getNote( size_type i ) { return scopes[i].note; }
+        const Note& getNote( size_type i ) const { return scopes[i].note; }
 
         /// Finds the given key in the outermost scope it occurs; returns end() for none such
         iterator find( const Key &key ) {
                 for ( size_type i = scopes.size() - 1; ; --i ) {
-                        typename Scope::iterator val = scopes[i].find( key );
-                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        typename MapType::iterator val = scopes[i].map.find( key );
+                        if ( val != scopes[i].map.end() ) return iterator( scopes, val, i );
                         if ( i == 0 ) break;
                 }
@@ -226 +262 @@
         }
         const_iterator find( const Key &key ) const {
-                        return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
+                        return const_iterator( const_cast< ScopedMap< Key, Value, Note >* >(this)->find( key ) );
         }
 
         /// Finds the given key in the provided scope; returns end() for none such
         iterator findAt( size_type scope, const Key& key ) {
-                typename Scope::iterator val = scopes[scope].find( key );
-                if ( val != scopes[scope].end() ) return iterator( scopes, val, scope );
+                typename MapType::iterator val = scopes[scope].map.find( key );
+                if ( val != scopes[scope].map.end() ) return iterator( scopes, val, scope );
                 return end();
         }
         const_iterator findAt( size_type scope, const Key& key ) const {
-                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findAt( scope, key ) );
+                return const_iterator( const_cast< ScopedMap< Key, Value, Note >* >(this)->findAt( scope, key ) );
         }
 
@@ -243 +279 @@
                 if ( it.level == 0 ) return end();
                 for ( size_type i = it.level - 1; ; --i ) {
-                        typename Scope::iterator val = scopes[i].find( key );
-                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        typename MapType::iterator val = scopes[i].map.find( key );
+                        if ( val != scopes[i].map.end() ) return iterator( scopes, val, i );
                         if ( i == 0 ) break;
                 }
@@ -250 +286 @@
         }
         const_iterator findNext( const_iterator &it, const Key &key ) const {
-                        return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) );
+                        return const_iterator( const_cast< ScopedMap< Key, Value, Note >* >(this)->findNext( it, key ) );
         }
 
@@ -256 +292 @@
         template< typename value_type_t >
         std::pair< iterator, bool > insert( value_type_t&& value ) {
-                std::pair< typename Scope::iterator, bool > res = scopes.back().insert( std::forward<value_type_t>( value ) );
+                std::pair< typename MapType::iterator, bool > res = scopes.back().map.insert( std::forward<value_type_t>( value ) );
                 return std::make_pair( iterator(scopes, std::move( res.first ), scopes.size()-1), std::move( res.second ) );
         }
@@ -262 +298 @@
         template< typename value_type_t >
         std::pair< iterator, bool > insert( iterator at, value_type_t&& value ) {
-                Scope& scope = (*at.scopes) [ at.level ];
-                std::pair< typename Scope::iterator, bool > res = scope.insert( std::forward<value_type_t>( value ) );
+                MapType& scope = (*at.scopes)[ at.level ].map;
+                std::pair< typename MapType::iterator, bool > res = scope.insert( std::forward<value_type_t>( value ) );
                 return std::make_pair( iterator(scopes, std::move( res.first ), at.level), std::move( res.second ) );
         }
@@ -272 +308 @@
         template< typename value_type_t >
         std::pair< iterator, bool > insertAt( size_type scope, value_type_t&& value ) {
-                std::pair< typename Scope::iterator, bool > res = scopes.at(scope).insert( std::forward<value_type_t>( value ) );
+                std::pair< typename MapType::iterator, bool > res = scopes.at(scope).map.insert( std::forward<value_type_t>( value ) );
                 return std::make_pair( iterator(scopes, std::move( res.first ), scope), std::move( res.second ) );
         }
@@ -288 +324 @@
 
         iterator erase( iterator pos ) {
-                Scope& scope = (*pos.scopes) [ pos.level ];
+                MapType& scope = (*pos.scopes)[ pos.level ].map;
                 const typename iterator::wrapped_iterator& new_it = scope.erase( pos.it );
                 iterator it( *pos.scopes, new_it, pos.level );

src/Parser/TypedefTable.cc

@@ -91 +91 @@
 
 void TypedefTable::enterScope() {
-        kindTable.beginScope();
+        kindTable.beginScope(0);
         debugPrint( cerr << "Entering scope " << kindTable.currentScope() << endl; print() );
 } // TypedefTable::enterScope

src/Parser/TypedefTable.h

@@ -23 +23 @@
 
 class TypedefTable {
-        typedef ScopedMap< std::string, int > KindTable;
+        typedef ScopedMap< std::string, int, int > KindTable;
         KindTable kindTable;    
-        unsigned int level = 0;
+        unsigned int level;
   public:
+    TypedefTable() : kindTable{0}, level{0} {}
         ~TypedefTable();
 

src/Parser/lex.ll

@@ -464 +464 @@
 void yyerror( const char * errmsg ) {
         SemanticErrorThrow = true;
-        cout << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
+        cerr << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
                  << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
 }

src/prelude/Makefile.am

@@ -43 +43 @@
 
 prelude.cf : prelude-gen.cc
-        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen
+        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
         @./prelude-gen > $@
         @rm ./prelude-gen
@@ -67 +67 @@
         rm -rf $(DEPDIR)
 
-MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c prelude.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}

src/prelude/Makefile.in

@@ -281 +281 @@
 cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
 noinst_DATA = ../libcfa/libcfa-prelude.c
-MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c prelude.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
 all: all-am
 
@@ -512 +512 @@
 
 prelude.cf : prelude-gen.cc
-        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen
+        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
         @./prelude-gen > $@
         @rm ./prelude-gen

src/prelude/prelude-gen.cc

@@ -121 +121 @@
                 if(mask & (1 << i)) {
                         result += name;
+                } else {
+                        result.append(name.size(), ' ');
                 }
                 i++;
@@ -148 +150 @@
         cout << endl;
 
-        cout << "void   ?{}( zero_t & );" << endl;
-        cout << "void   ?{}( one_t & );" << endl;
-        cout << "void   ?{}( zero_t &, zero_t );" << endl;
-        cout << "void   ?{}( one_t &, one_t );" << endl;
-        cout << "void   ^?{}( zero_t & );" << endl;
-        cout << "void   ^?{}( one_t & );" << endl;
-        cout << "zero_t                 ?=?( zero_t &, zero_t );" << endl;
-        cout << "one_t                  ?=?( one_t &, one_t );" << endl;
         cout << "signed int ?==?( zero_t, zero_t ),                                                     ?!=?( zero_t, zero_t );" << endl;
         cout << "signed int ?==?( one_t, one_t ),                                                       ?!=?( one_t, one_t );" << endl;
-
         cout << "signed int ?==?( _Bool, _Bool ),                                                       ?!=?( _Bool, _Bool );" << endl;
-        cout << "void   ?{}( _Bool & );" << endl;
-        cout << "void   ?{}( _Bool &, _Bool );" << endl;
-        cout << "void   ^?{}( _Bool & );" << endl;
-        cout << "_Bool                  ?=?( _Bool &, _Bool ),                                  ?=?( volatile _Bool &, _Bool );" << endl;
         cout << "signed int     !?( _Bool );" << endl;
-
-        cout << "void   ^?{}( char & );" << endl;
-        cout << "void   ^?{}( char unsigned & );" << endl;
-        cout << "void   ^?{}( char signed & );" << endl;
-        cout << "void   ?{}( char &, char );" << endl;
-        cout << "void   ?{}( unsigned char &, unsigned char );" << endl;
-        cout << "void   ?{}( char signed &, char signed );" << endl;
-        cout << "void   ?{}( char & );" << endl;
-        cout << "void   ?{}( unsigned char & );" << endl;
-        cout << "void   ?{}( char signed & );" << endl;
-        cout << "char                   ?=?( char &, char ),                                    ?=?( volatile char &, char );" << endl;
-        cout << "char signed            ?=?( char signed &, char signed ),                      ?=?( volatile char signed &, char signed );" << endl;
-        cout << "char unsigned          ?=?( char unsigned &, char unsigned ),                  ?=?( volatile char unsigned &, char unsigned );" << endl;
-
 
         for (auto op : arithmeticOperators) {
@@ -213 +188 @@
         cout << "// Arithmetic Constructors //" << endl;
         cout << "/////////////////////////////" << endl;
+        auto otype = [](const std::string & type, bool do_volatile = false) {
+                cout << "void \t?{} ( " << type << " & );" << endl;
+                cout << "void \t?{} ( " << type << " &, " << type << " );" << endl;
+                cout << type << " \t?=? ( " << type << " &, " << type << " )";
+                if( do_volatile ) {
+                        cout << ", \t?=?( volatile " << type << " &, " << type << " )";
+                }
+                cout << ";" << endl;
+                cout << "void \t^?{}( " << type << " & );" << endl;
+        };
+
+        otype("zero_t");
+        otype("one_t");
+        otype("_Bool", true);
+        otype("char", true);
+        otype("signed char", true);
+        otype("unsigned char", true);
+
         for (auto type : basicTypes) {
                 cout << "void  ?{}(" << type.name << " &);" << endl;
@@ -227 +220 @@
         cout << "forall(ftype FT) void  ?{}( FT * volatile &, FT * );" << endl;
 
-        // generate qualifiers for first and second parameters of copy constructors
+        // generate qualifiers
+        vector<string> qualifiersSingle;
         vector<pair<const string, const string>> qualifiersPair;
         const unsigned int NQ = 2;
         for(unsigned int lhs = 0; lhs < (1<<NQ); lhs++) {
+                // for parameter of default constructor and destructor
+                qualifiersSingle.push_back(mask2string(lhs, make_array("const "s, "volatile "s)));
+
+                // for first and second parameters of copy constructors
                 for(unsigned int rhs = 0; rhs < (1<<NQ); rhs++) {
                         if((lhs & rhs) == rhs) {
@@ -241 +239 @@
         }
 
-        for (auto type : { "DT", "void" }) {
-                for (auto q : qualifiersPair) {
-                        cout << "forall(dtype DT) void  ?{}(" << q.first << type << " *&, " << q.second << "DT *);" << endl;
-                }
-        }
-
-
-        // generate qualifiers for parameter of default constructor and destructor
-        vector<string> qualifiersSingle;
-        for (unsigned int lhs = 0; lhs < (1<<NQ); lhs++) {
-                qualifiersSingle.push_back(mask2string(lhs, make_array("const "s, "volatile "s)));
-        }
-
-        for (auto type : { "DT", "void" }) {
-                for (auto q : qualifiersSingle) {
-                        cout << "forall(dtype DT) void  ?{}(" << q << type << " *&);" << endl;
-                        cout << "forall(dtype DT) void ^?{}(" << q << type << " *&);" << endl;
-                }
-        }
-        cout << endl;
-
-        cout << "forall(dtype DT) void ?{}(                 DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) void ?{}(                 DT * volatile &, zero_t );" << endl;
-        cout << "forall(dtype DT) void ?{}( const           DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) void ?{}( volatile        DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) void ?{}( volatile        DT * volatile &, zero_t );" << endl;
-        cout << "forall(dtype DT) void ?{}( const volatile DT *   &, zero_t );" << endl;
+        for (auto type : { "  DT", "void" }) {
+                for (auto cvq : qualifiersPair) {
+                        for (auto is_vol : { "        ", "volatile" }) {
+                                cout << "forall(dtype DT) void  ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
+                        }
+                }
+                for (auto cvq : qualifiersSingle) {
+                        for (auto is_vol : { "        ", "volatile" }) {
+                                cout << "forall(dtype DT) void  ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
+                        }
+                        for (auto is_vol : { "        ", "volatile" }) {
+                                cout << "forall(dtype DT) void ^?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
+                        }
+                }
+        }
+
+        {
+                auto type = "  DT";
+                for (auto is_vol : { "        ", "volatile" }) {
+                        for (auto cvq : qualifiersSingle) {
+                                cout << "forall(dtype DT) void ?{}( " << cvq << type << " * " << is_vol << " &, zero_t);" << endl;
+                        }
+                }
+        }
+
+        cout << endl;
+
         cout << "forall(ftype FT) void  ?{}( FT *          &, zero_t ); " << endl;
+        cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
+        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
         cout << "forall( ftype FT ) void        ?{}( FT *          & );" << endl;
         cout << "forall( ftype FT ) void        ^?{}( FT *         & );" << endl;
@@ -285 +285 @@
 
 
-        cout << "forall( dtype DT ) void *               ?=?(                void *          &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) void *               ?=?(                void * volatile &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) const void *                 ?=?( const          void *          &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) const void *                 ?=?( const          void * volatile &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) const void *                 ?=?( const          void *          &, const           DT * );" << endl;
-        cout << "forall( dtype DT ) const void *                 ?=?( const          void * volatile &, const           DT * );" << endl;
-        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void *          &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void * volatile &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void *          &,       volatile  DT * );" << endl;
-        cout << "forall( dtype DT ) volatile void *      ?=?(       volatile void * volatile &,       volatile  DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &,                 DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,                        DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &, const           DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const          DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &,       volatile  DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,              volatile  DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void *         &, const volatile  DT * );" << endl;
-        cout << "forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * );" << endl;
-
         for (auto op : pointerOperators) {
+                auto forall = [&op]() {
+                        cout << "forall(dtype DT" << op.sized << ") ";
+                };
                 for (auto type : { "DT"/*, "void"*/ } ) {
                         auto operands = count(op.name.begin(), op.name.end(), '?');
@@ -313 +297 @@
                                                 if (operands == 1) {
                                                         for (auto q : qualifiersSingle){
-                                                                for (auto q2 : { " ", " volatile " }) {
-                                                                        cout << "forall(dtype DT" << op.sized <<  ") ";
+                                                                for (auto q2 : { "        ", "volatile" }) {
+                                                                        forall();
                                                                         cout << q << type << " * " << op.name << "(";
-                                                                        cout << q << type << " *" << q2 << "&";
+                                                                        cout << q << type << " * " << q2 << " &";
                                                                         cout << ");" << endl;
                                                                 }
@@ -322 +306 @@
                                                 } else {
                                                         for (auto q : qualifiersPair){
-                                                                for (auto q2 : { " ", " volatile " }) {
-                                                                        cout << "forall(dtype DT" << op.sized <<  ") ";
+                                                                for (auto q2 : { "        ", "volatile" }) {
+                                                                        forall();
                                                                         cout << q.first << type << " * " << op.name << "(";
-                                                                        cout << q.first << type << " *" << q2 << "&";
+                                                                        cout << q.first << type << " * " << q2 << " &";
 
                                                                         for (int i = 1; i < operands; ++i) {
@@ -337 +321 @@
                                         case PtrDiff:
                                                 for (auto q : qualifiersSingle){
-                                                        for (auto q2 : { " ", " volatile " }) {
-                                                                cout << "forall(dtype DT" << op.sized << ") ";
+                                                        for (auto q2 : { "        ", "volatile" }) {
+                                                                forall();
                                                                 cout << q << type << " * " << op.name << "(";
-                                                                cout << q << type << " *" << q2 << "&";
+                                                                cout << q << type << " * " << q2 << " &";
 
                                                                 for (int i = 1; i < operands; ++i) {
@@ -353 +337 @@
                                         }
                         } else {
+                                auto name_and_arg1 = [&op, &type](const std::string & q) {
+                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
+                                        else if (op.diffReturn != "") cout << op.diffReturn;
+                                        else cout << q << type << " *";
+                                        cout << " " << op.name << "(";
+                                };
                                 switch(op.diffArg2) {
                                         case Normal:
                                                 for (auto q : qualifiersSingle) {
-                                                        cout << "forall(dtype DT" << op.sized << ") ";
-                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
-                                                        else if (op.diffReturn != "") cout << op.diffReturn;
-                                                        else cout << q << type << " *";
-                                                        cout << " " << op.name << "(";
+                                                        forall();
+                                                        name_and_arg1( q );
                                                         for (int i = 0; i < operands; ++i) {
                                                                 cout << q << type << " *";
@@ -370 +357 @@
                                         case CommPtrDiff:
                                                 for (auto q : qualifiersSingle) {
-                                                        cout << "forall(dtype DT" << op.sized << ") ";
-                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
-                                                        else if (op.diffReturn != "") cout << op.diffReturn;
-                                                        else cout << q << type << " *";
-                                                        cout << " " << op.name << "(ptrdiff_t, " << q << type << " *);" << endl;
+                                                        forall();
+                                                        name_and_arg1( q );
+                                                        cout << "ptrdiff_t, " << q << type << " *);" << endl;
                                                 }
                                                 // fallthrough
                                         case PtrDiff:
                                                 for (auto q : qualifiersSingle) {
-                                                        cout << "forall(dtype DT" << op.sized << ") ";
-                                                        if (op.diffReturn == "&") cout << q << type << " &"; // -- qualifiers
-                                                        else if (op.diffReturn != "") cout << op.diffReturn;
-                                                        else cout << q << type << " *";
-                                                        cout << " " << op.name << "(" << q << type << " *, ptrdiff_t);" << endl;
+                                                        forall();
+                                                        name_and_arg1( q );
+                                                        cout << q << type << " *, ptrdiff_t);" << endl;
                                                 }
                                                 break;
@@ -393 +376 @@
         cout << endl;
 
-        cout << "forall(dtype DT) DT *                  ?=?(                DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) DT *                  ?=?(                DT * volatile &, zero_t );" << endl;
-        cout << "forall(dtype DT) const DT *            ?=?( const          DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) const DT *            ?=?( const          DT * volatile &, zero_t );" << endl;
-        cout << "forall(dtype DT) volatile DT * ?=?( volatile       DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) volatile DT * ?=?( volatile       DT * volatile &, zero_t );" << endl;
-        cout << "forall(dtype DT) const volatile DT *   ?=?( const volatile DT *          &, zero_t );" << endl;
-        cout << "forall(dtype DT) const volatile DT *   ?=?( const volatile DT * volatile &, zero_t );" << endl;
-        cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
-        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
+        for (auto is_vol : { "        ", "volatile" }) {
+                for (auto cvq : qualifiersPair) {
+                                cout << "forall(dtype DT) " << cvq.first << "void * ?=?( " << cvq.first << "void * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
+                }
+                for (auto cvq : qualifiersSingle) {
+                        cout << "forall(dtype DT) " << cvq <<   "  DT * ?=?( " << cvq << "  DT * " << is_vol << " &, zero_t);" << endl;
+                }
+        }
+        cout << endl;
 }
 

src/tests/.expect/attributes.x86.txt

@@ +1 @@
+signed int __la__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_la__i_1;
+    L: __attribute__ ((unused)) ((void)1);
+}
+struct __attribute__ ((unused)) __anonymous0 {
+};
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    struct __anonymous0 ___ret__13s__anonymous0_1;
+    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
+struct __attribute__ ((unused)) Agn1;
+struct __attribute__ ((unused)) Agn2 {
+};
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+    struct Agn2 ___ret__5sAgn2_1;
+    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
+    return ___ret__5sAgn2_1;
+}
+enum __attribute__ ((unused)) __anonymous1 {
+    __E1__C13e__anonymous1_1,
+};
+enum __attribute__ ((unused)) Agn3;
+enum __attribute__ ((packed)) Agn3 {
+    __E2__C5eAgn3_1,
+};
+struct __attribute__ ((unused)) __anonymous2 {
+};
+static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+}
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+}
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+}
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    struct __anonymous2 ___ret__13s__anonymous2_1;
+    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
+    return ___ret__13s__anonymous2_1;
+}
+struct __attribute__ ((unused)) Agn4 {
+};
+static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
+static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
+static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1);
+static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1);
+static inline void ___constructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
+}
+static inline void ___constructor__F_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
+}
+static inline void ___destructor__F_5sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1){
+}
+static inline struct Agn4 ___operator_assign__F5sAgn4_5sAgn45sAgn4_autogen___1(struct Agn4 *___dst__5sAgn4_1, struct Agn4 ___src__5sAgn4_1){
+    struct Agn4 ___ret__5sAgn4_1;
+    ((void)___constructor__F_5sAgn45sAgn4_autogen___1((&___ret__5sAgn4_1), (*___dst__5sAgn4_1)));
+    return ___ret__5sAgn4_1;
+}
+struct Fdl {
+    __attribute__ ((unused)) signed int __f1__i_1;
+    __attribute__ ((unused)) signed int __f2__i_1;
+    __attribute__ ((unused,unused)) signed int __f3__i_1;
+    __attribute__ ((unused)) signed int __f4__i_1;
+    __attribute__ ((unused,unused)) signed int __f5__i_1;
+    __attribute__ ((used,packed)) signed int __f6__i_1;
+    __attribute__ ((used,unused,unused)) signed int __f7__i_1;
+    __attribute__ ((used,used,unused)) signed int __f8__i_1;
+    __attribute__ ((unused)) signed int __anonymous_object0;
+    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
+};
+static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
+static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
+}
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
+    struct Fdl ___ret__4sFdl_1;
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
+    return ___ret__4sFdl_1;
+}
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
+__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
+__attribute__ ((used,used)) const signed int __vd1__Ci_1;
+__attribute__ ((used,unused)) const signed int __vd2__Ci_1;
+__attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1;
+__attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1;
+__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
+__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
+__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
+__attribute__ ((unused,used)) signed int __f1__Fi___1();
+__attribute__ ((unused)) signed int __f1__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_f1__i_1;
+}
+__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
+__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
+    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
+__attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
+    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
+}
+signed int __vtr__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_vtr__i_1;
+    __attribute__ ((unused,unused,used)) signed int __t1__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2;
+    __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2();
+    __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2();
+}
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1);
+signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){
+    __attribute__ ((unused)) signed int ___retval_ipd1__i_1;
+}
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd2__i_1;
+}
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1);
+signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){
+    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
+}
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
+    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
+}
+signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1);
+signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
+signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
+signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
+signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
+signed int __ad__Fi___1(){
+    __attribute__ ((unused)) signed int ___retval_ad__i_1;
+    __attribute__ ((used,unused)) signed int __ad1__i_2;
+    __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2;
+    __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)];
+    __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2();
+    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
+    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
+    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
+    struct __attribute__ ((unused)) __anonymous3 {
+        signed int __i__i_2;
+    };
+    inline void ___constructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
+        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ?{} */);
+    }
+    inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
+        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2){
+        ((void)((*___dst__13s__anonymous3_2).__i__i_2) /* ^?{} */);
+    }
+    inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, struct __anonymous3 ___src__13s__anonymous3_2){
+        struct __anonymous3 ___ret__13s__anonymous3_2;
+        ((void)((*___dst__13s__anonymous3_2).__i__i_2=___src__13s__anonymous3_2.__i__i_2));
+        ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___2((&___ret__13s__anonymous3_2), (*___dst__13s__anonymous3_2)));
+        return ___ret__13s__anonymous3_2;
+    }
+    inline void ___constructor__F_13s__anonymous3i_autogen___2(struct __anonymous3 *___dst__13s__anonymous3_2, signed int __i__i_2){
+        ((void)((*___dst__13s__anonymous3_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
+    ((void)sizeof(struct __anonymous3 ));
+    enum __attribute__ ((unused)) __anonymous4 {
+        __R__C13e__anonymous4_2,
+    };
+    inline void ___constructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
+    }
+    inline void ___constructor__F_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
+        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13e__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *___dst__13e__anonymous4_2){
+    }
+    inline enum __anonymous4 ___operator_assign__F13e__anonymous4_13e__anonymous413e__anonymous4_intrinsic___2(enum __anonymous4 *___dst__13e__anonymous4_2, enum __anonymous4 ___src__13e__anonymous4_2){
+        enum __anonymous4 ___ret__13e__anonymous4_2;
+        ((void)((*___dst__13e__anonymous4_2)=___src__13e__anonymous4_2));
+        ((void)(___ret__13e__anonymous4_2=(*___dst__13e__anonymous4_2)) /* ?{} */);
+        return ___ret__13e__anonymous4_2;
+    }
+    ((void)sizeof(enum __anonymous4 ));
+}
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
+struct Vad {
+    __attribute__ ((unused)) signed int __anonymous_object32;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
+    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
+};
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index0 = 0;
+        for (;(_index0<10);((void)(++_index0))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
+        signed int _index1 = 0;
+        for (;(_index1<10);((void)(++_index1))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
+        signed int _index2 = (10-1);
+        for (;(_index2>=0);((void)(--_index2))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
+}
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
+    struct Vad ___ret__4sVad_1;
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
+    {
+        signed int _index3 = 0;
+        for (;(_index3<10);((void)(++_index3))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
+    return ___ret__4sVad_1;
+}
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index4 = 0;
+        for (;(_index4<10);((void)(++_index4))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
+        signed int _index5 = 0;
+        for (;(_index5<10);((void)(++_index5))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
+        signed int _index6 = 0;
+        for (;(_index6<10);((void)(++_index6))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
+        signed int _index7 = 0;
+        for (;(_index7<10);((void)(++_index7))) {
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
+        }
+
+    }
+
+    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/Makefile.am

@@ -17 +17 @@
 debug=yes
 
-quick_test=avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
+quick_test=avl_test operators numericConstants expression enum array typeof cast attributes
 
 if BUILD_CONCURRENCY

src/tests/attributes.c

@@ -10 +10 @@
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 23:05:52 2017
-// Update Count     : 3
+// Last Modified On : Sun Jul  8 21:12:07 2018
+// Update Count     : 8
 // 
 
@@ -29 +29 @@
 enum __attribute__(( packed )) Agn3 { E2 };
 #ifdef __CFA__
-struct __attribute__(( unused )) ( int ) {};
-struct __attribute__(( unused )) ( int ) {};
+struct __attribute__(( unused )) {} ( int );
+struct __attribute__(( unused )) Agn4 {} ( int );
 #endif // __CFA__