Changeset d27e340

Timestamp:

Feb 15, 2018, 11:11:00 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

271326e, ac7d921, d55d7a6

Parents:

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

Message:

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

Files:

• doc/LaTeXmacros/common.tex (modified) (3 diffs)
• doc/papers/general/Paper.tex (modified) (27 diffs)
• doc/user/user.tex (modified) (62 diffs)
• src/Parser/parser.yy (modified) (4 diffs)
• src/tests/alloc.c (modified) (2 diffs)

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun Feb  4 10:38:26 2018
-%% Update Count     : 365
+%% Last Modified On : Tue Feb 13 08:19:07 2018
+%% Update Count     : 367
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -177 +177 @@
 \makeatother
 
-\newenvironment{quote2}{%
-        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
+\newenvironment{cquote}{%
+        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
         \item\relax
 }{%
         \endlist
-}% quote2
+}% cquote
 
 \newenvironment{rationale}{%
-  \begin{quote2}\noindent$\Box$\enspace
+  \begin{cquote}\noindent$\Box$\enspace
 }{%
-  \hfill\enspace$\Box$\end{quote2}
+  \hfill\enspace$\Box$\end{cquote}
 }%
 
@@ -201 +201 @@
 \newenvironment{syntax}{
 \paragraph{Syntax}
-\begin{quote2}
+\begin{cquote}
 \begin{description}[noitemsep,leftmargin=\parindentlnth]
 }{
 \end{description}
-\end{quote2}
+\end{cquote}
 }
 % \def\syntax{\paragraph{Syntax}\trivlist\parindent=.5in\item[\hskip.5in]}

doc/papers/general/Paper.tex

@@ -4 +4 @@
 \usepackage{epic,eepic}
 \usepackage{xspace,calc,comment}
-\usepackage{upquote}                                                                    % switch curled `'" to straight
-\usepackage{listings}                                                                   % format program code
+\usepackage{upquote}                                            % switch curled `'" to straight
+\usepackage{listings}                                           % format program code
+\usepackage{enumitem}
+\usepackage[flushmargin]{footmisc}                      % support label/reference in footnote
 \usepackage{rotating}
 \usepackage[usenames]{color}
-\usepackage{pslatex}                                    % reduce size of san serif font
+\usepackage{pslatex}                                            % reduce size of san serif font
 \usepackage[plainpages=false,pdfpagelabels,pdfpagemode=UseNone,pagebackref=true,breaklinks=true,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
 
 \setlength{\textheight}{9in}
 %\oddsidemargin 0.0in
-\renewcommand{\topfraction}{0.8}                % float must be greater than X of the page before it is forced onto its own page
-\renewcommand{\bottomfraction}{0.8}             % float must be greater than X of the page before it is forced onto its own page
-\renewcommand{\floatpagefraction}{0.8}  % float must be greater than X of the page before it is forced onto its own page
-\renewcommand{\textfraction}{0.0}               % the entire page maybe devoted to floats with no text on the page at all
-
-\lefthyphenmin=4                                                % hyphen only after 4 characters
+\renewcommand{\topfraction}{0.8}                        % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\bottomfraction}{0.8}                     % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\floatpagefraction}{0.8}          % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\textfraction}{0.0}                       % the entire page maybe devoted to floats with no text on the page at all
+
+\lefthyphenmin=4                                                        % hyphen only after 4 characters
 \righthyphenmin=4
 
@@ -24 +26 @@
 
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
-\newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
-\newcommand{\CFL}{\textrm{Cforall}\xspace} % Cforall symbolic name
-\newcommand{\Celeven}{\textrm{C11}\xspace} % C11 symbolic name
+\newcommand{\CFA}{\protect\CFAIcon}             % safe for section/caption
+\newcommand{\CFL}{\textrm{Cforall}\xspace}      % Cforall symbolic name
+\newcommand{\Celeven}{\textrm{C11}\xspace}      % C11 symbolic name
 \newcommand{\CC}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}\xspace} % C++ symbolic name
 \newcommand{\CCeleven}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
@@ -56 +58 @@
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 
-\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
+\newlength{\gcolumnposn}                                        % temporary hack because lstlisting does not handle tabs correctly
 \newlength{\columnposn}
 \setlength{\gcolumnposn}{2.75in}
@@ -72 +74 @@
 
 % Latin abbreviation
-\newcommand{\abbrevFont}{\textit}       % set empty for no italics
+\newcommand{\abbrevFont}{\textit}                       % set empty for no italics
 \newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
 \newcommand*{\eg}{%
@@ -103 +105 @@
 
 \newenvironment{cquote}{%
-        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
+        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
         \item\relax
 }{%
@@ -193 +195 @@
 The TIOBE~\cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail.
 The top 3 rankings over the past 30 years are:
-\lstDeleteShortInline@%
 \begin{center}
 \setlength{\tabcolsep}{10pt}
+\lstDeleteShortInline@%
 \begin{tabular}{@{}rccccccc@{}}
                 & 2017  & 2012  & 2007  & 2002  & 1997  & 1992  & 1987          \\ \hline
@@ -202 +204 @@
 \CC             & 3             & 3             & 3             & 3             & 2             & 2             & 4                     \\
 \end{tabular}
+\lstMakeShortInline@%
 \end{center}
-\lstMakeShortInline@%
 Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
 In many cases, \CC is often used solely as a better C.
@@ -257 +259 @@
 Crucial to the design of a new programming language are the libraries to access thousands of external software features.
 Like \CC, \CFA inherits a massive compatible library-base, where other programming languages must rewrite or provide fragile inter-language communication with C.
-A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted floating-point array:
+A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
 \begin{lstlisting}
 void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
@@ -263 +265 @@
 int comp( const void * t1, const void * t2 ) { return *(double *)t1 < *(double *)t2 ? -1 :
                                 *(double *)t2 < *(double *)t1 ? 1 : 0; }
-double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
+double key = 5.0, vals[10] = { /* 10 sorted float values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
 \end{lstlisting}
@@ -505 +507 @@
 In many languages, functions can return at most one value;
 however, many operations have multiple outcomes, some exceptional.
-Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and floating-point values, respectively.
+Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and float values, respectively.
 \begin{lstlisting}
 typedef struct { int quo, rem; } div_t;         $\C{// from include stdlib.h}$
@@ -936 +938 @@
 
 \section{Control Structures}
+
+\CFA identifies missing and problematic control structures in C, and extends and modifies these control structures to increase functionality and safety.
 
 
@@ -1044 +1048 @@
 The implicit targets of the current @continue@ and @break@, \ie the closest enclosing loop or @switch@, change as certain constructs are added or removed.
 
+
 \subsection{\texorpdfstring{Enhanced \LstKeywordStyle{switch} Statement}{Enhanced switch Statement}}
 
-\CFA also fixes a number of ergonomic defecits in the @switch@ statements of standard C. 
-C can specify a number of equivalent cases by using the default ``fall-through'' semantics of @case@ clauses, \eg @case 1: case 2: case 3:@ -- this syntax is cluttered, however, so \CFA includes a more concise list syntax, @case 1, 2, 3:@. 
-For contiguous ranges, \CFA provides an even more concise range syntax as well, @case 1~3:@; lists of ranges are also allowed in case selectors. 
-
+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.
+
+C has no shorthand for specifying a list of case values, whether the list is non-contiguous or contiguous\footnote{C provides this mechanism via fall through.}.
+\CFA provides a shorthand for a non-contiguous list:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+case 2, 10, 34, 42:
+\end{cfa}
+&
+\begin{cfa}
+case 2: case 10: case 34: case 42:
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+for a contiguous list:\footnote{gcc provides the same mechanism with awkward syntax, \lstinline@2 ... 42@, where spaces are required around the ellipse.}
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+case 2~42:
+\end{cfa}
+&
+\begin{cfa}
+case 2: case 3: ... case 41: case 42:
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+and a combination:
+\begin{cfa}
+case -12~-4, -1~5, 14~21, 34~42:
+\end{cfa}
+
+C allows placement of @case@ clauses \emph{within} statements nested in the @switch@ body (see Duff's device~\cite{Duff83});
+\begin{cfa}
+switch ( i ) {
+  case 0:
+        for ( int i = 0; i < 10; i += 1 ) {
+                ...
+  `case 1:`             // no initialization of loop index
+                ...
+        }
+}
+\end{cfa}
+\CFA precludes this form of transfer into a control structure because it causes undefined behaviour, especially with respect to missed initialization, and provides very limited functionality.
+
+C allows placement of declaration within the @switch@ body and unreachable code at the start, resulting in undefined behaviour:
+\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 undefined}$
+}
+\end{cfa}
+\CFA allows the declaration of local variables, \eg @y@, at the start of the @switch@ with scope across the entire @switch@ body, \ie all @case@ clauses, but no statements.
+\CFA disallows the declaration of local variable, \eg @z@, directly within the @switch@ body, because a declaration cannot occur immediately after a @case@ since a label can only be attached to a statement, and the use of @z@ is undefined in @case 1@ as neither storage allocation nor initialization may have occurred.
+
+C @switch@ provides multiple entry points into the statement body, but once an entry point is selected, control continues across \emph{all} @case@ clauses until the end of the @switch@ body, called \newterm{fall through};
+@case@ clauses are made disjoint by the @break@ statement.
+While the ability to fall through \emph{is} a useful form of control flow, it does not match well with programmer intuition, resulting in many errors from missing @break@ statements.
+\CFA provides a new control structure, @choose@, which mimics @switch@, but reverses the meaning of fall through:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+`choose` ( day ) {
+  case Mon~Thu:
+        // program
+
+  case Fri:
+        // program
+        wallet += pay;
+        `fallthrough;`
+  case Sat:
+        // party
+        wallet -= party;
+
+  case Sun:
+        // rest
+
+  default:
+        // error
+}
+\end{cfa}
+&
+\begin{cfa}
+switch ( day ) {
+  case Mon: case Tue: case Wed: case Thu:
+        // program
+        `break;`
+  case Fri:
+        // program
+        wallet += pay;
+
+  case Sat:
+        // party
+        wallet -= party;
+        `break;`
+  case Sun:
+        // rest
+        `break;`
+  default:
+        // error
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Collectively, these enhancements reduce programmer burden and increase readability and safety.
+
+\begin{comment}
 Forgotten @break@ statements at the end of @switch@ cases are a persistent sort of programmer error in C, and the @break@ statements themselves introduce visual clutter and an un-C-like keyword-based block delimiter. 
 \CFA addresses this error by introducing a @choose@ statement, which works identically to a @switch@ except that its default end-of-case behaviour is to break rather than to fall through for all non-empty cases. 
@@ -1070 +1193 @@
 }
 \end{cfa}
+\end{comment}
+
 
 \subsection{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
@@ -1255 +1380 @@
 \lstDeleteShortInline@%
 \lstset{moredelim=**[is][\color{blue}]{+}{+}}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 +[5] *+ `int` x1;
 +* [5]+ `int` x2;
-+[* [5] int]+ f`( int p )`;
+`[* [5] int]` f+( int p )+;
 \end{cfa}
 &
@@ -1266 +1391 @@
 `int` +*+ x1 +[5]+;
 `int` +(*+x2+)[5]+;
-+int (*+f`( int p )`+)[5]+;
+`int (*`f+( int p )+`)[5]`;
 \end{cfa}
 \end{tabular}
@@ -1277 +1402 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 `*` int x, y;
@@ -1292 +1417 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 `*` int x;
@@ -1310 +1435 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 [ 5 ] int z;
@@ -1351 +1476 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
-\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 const * const int x;
@@ -1374 +1499 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 extern [ 5 ] int x;
@@ -1397 +1522 @@
 \begin{cquote}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 y = (* int)x;
@@ -1415 +1540 @@
 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
+
+The syntax of the new routine prototype declaration follows directly from the new routine definition syntax;
+as well, parameter names are optional, \eg:
+\begin{cfa}
+[ int x ] f ();                                                 $\C{// returning int with no parameters}$
+[ * int ] g (int y);                                    $\C{// returning pointer to int with int parameter}$
+[ ] h ( int, char );                                    $\C{// returning no result with int and char parameters}$
+[ * int, int ] j ( int );                               $\C{// returning pointer to int and int, with int parameter}$
+\end{cfa}
+This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
+Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+[double] foo(), foo( int ), foo( double ) {...}
+\end{cfa}
+&
+\begin{cfa}
+double foo1(), foo2( int ), foo3( double );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+\CFA allows the last routine in the list to define its body.
+
+Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
+\begin{cfa}
+extern [ int ] f ( int );
+static [ int ] g ( int );
+\end{cfa}
+
+The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
+\begin{cfa}
+* [ int x ] () fp;                                              $\C{// pointer to routine returning int with no parameters}$
+* [ * int ] (int y) gp;                                 $\C{// pointer to routine returning pointer to int with int parameter}$
+* [ ] (int,char) hp;                                    $\C{// pointer to routine returning no result with int and char parameters}$
+* [ * int,int ] ( int ) jp;                             $\C{// pointer to routine returning pointer to int and int, with int parameter}$
+\end{cfa}
+While parameter names are optional, \emph{a routine name cannot be specified};
+for example, the following is incorrect:
+\begin{cfa}
+* [ int x ] f () fp;                                    $\C{// routine name "f" is not allowed}$
+\end{cfa}
 
 
@@ -1593 +1763 @@
 In addition to the expressive power, \lstinline|@=| provides a simple path for migrating legacy C code to \CFA, by providing a mechanism to incrementally convert initializers; the \CFA design team decided to introduce a new syntax for this escape hatch because we believe that our RAII implementation will handle the vast majority of code in a desirable way, and we wished to maintain familiar syntax for this common case.
 
+
+\subsection{Type Nesting}
+
+\CFA allows \newterm{type nesting}, and type qualification of the nested types (see Figure~\ref{f:TypeNestingQualification}), where as C hoists (refactors) nested types into the enclosing scope and has no type qualification.
+\begin{figure}
+\centering
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
+\hline
+\begin{cfa}
+struct S {
+        enum C { R, G, B };
+        struct T {
+                union U { int i, j; };
+                enum C c;
+                short int i, j;
+        };
+        struct T t;
+} s;
+
+int rtn() {
+        s.t.c = R;
+        struct T t = { R, 1, 2 };
+        enum C c;
+        union U u;
+}
+\end{cfa}
+&
+\begin{cfa}
+enum C { R, G, B };
+union U { int i, j; };
+struct T {
+        enum C c;
+        short int i, j;
+};
+struct S {
+        struct T t;
+} s;
+        
+
+
+
+
+
+
+\end{cfa}
+&
+\begin{cfa}
+struct S {
+        enum C { R, G, B };
+        struct T {
+                union U { int i, j; };
+                enum C c;
+                short int i, j;
+        };
+        struct T t;
+} s;
+
+int rtn() {
+        s.t.c = `S.`R;  // type qualification
+        struct `S.`T t = { `S.`R, 1, 2 };
+        enum `S.`C c;
+        union `S.T.`U u;
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\caption{Type Nesting / Qualification}
+\label{f:TypeNestingQualification}
+\end{figure}
+In the left example in C, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
+In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@''.
+
+
 \subsection{Default Parameters}
 
@@ -1598 +1843 @@
 \section{Literals}
 
-C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and floating-point types are very similar, differing from each other only in suffix.
+C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and float types are very similar, differing from each other only in suffix.
 In keeping with the general \CFA approach of adding features while respecting ``the C way'' of doing things, we have extended both C's polymorphic zero and typed literal syntax to interoperate with user-defined types, while maintaining a backwards-compatible semantics.
 
@@ -1622 +1867 @@
 struct Weight { double stones; };
 
-void ?{}( Weight & w ) { w.stones = 0; } $\C{// operations}$
+void ?{}( Weight & w ) { w.stones = 0; }        $\C{// operations}$
 void ?{}( Weight & w, double w ) { w.stones = w; }
 Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; }
@@ -1631 +1876 @@
 
 int main() {
-        Weight w, hw = { 14 };                  $\C{// 14 stone}$
+        Weight w, hw = { 14 };                                  $\C{// 14 stone}$
         w = 11@`st@ + 1@`lb@;
         w = 70.3@`kg@;
         w = 155@`lb@;
-        w = 0x_9b_u@`lb@;                               $\C{// hexadecimal unsigned weight (155)}$
-        w = 0_233@`lb@;                                 $\C{// octal weight (155)}$
+        w = 0x_9b_u@`lb@;                                               $\C{// hexadecimal unsigned weight (155)}$
+        w = 0_233@`lb@;                                                 $\C{// octal weight (155)}$
         w = 5@`st@ + 8@`kg@ + 25@`lb@ + hw;
 }
 \end{cfa}
 }%
+
+
+\section{Libraries}
+
+As stated in Section~\ref{sec:poly-fns}, \CFA inherits a large corpus of library code, where other programming languages must rewrite or provide fragile inter-language communication with C.
+\CFA has replacement libraries condensing hundreds of existing C names into tens of \CFA overloaded names, all without rewriting the actual computations.
+In many cases, the interface is an inline wrapper providing overloading during compilation but zero cost at runtime.
+The following sections give a glimpse of the interface reduction to many C libraries.
+In many cases, @signed@/@unsigned@ @char@ and @short@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results.
+
+
+\subsection{Limits}
+
+C library @limits.h@ provides lower and upper bound constants for the basic types.
+\CFA name overloading is used to condense these typed constants, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+const short int `MIN` = -32768;
+const int `MIN` = -2147483648;
+const long int `MIN` = -9223372036854775808L;
+\end{cfa}
+&
+\begin{cfa}
+short int si = `MIN`;
+int i = `MIN`;
+long int li = `MIN`;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access typed constants, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+MIN
+MAX
+M_PI
+M_E
+\end{cfa}
+&
+\begin{cfa}
+SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
+SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
+M_PI, M_PIl, M_CPI, M_CPIl,
+M_E, M_El, M_CE, M_CEl
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+
+
+\subsection{Math}
+
+C library @math.h@ provides many mathematical routines.
+\CFA routine overloading is used to condense these mathematical routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+float `log`( float x );
+double `log`( double );
+double _Complex `log`( double _Complex x );
+\end{cfa}
+&
+\begin{cfa}
+float f = `log`( 3.5 );
+double d = `log`( 3.5 );
+double _Complex dc = `log`( 3.5+0.5I );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access math routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+log
+sqrt
+sin
+\end{cfa}
+&
+\begin{cfa}
+logf, log, logl, clogf, clog, clogl
+sqrtf, sqrt, sqrtl, csqrtf, csqrt, csqrtl
+sinf, sin, sinl, csinf, csin, csinl
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a routine name with a single set of floating type(s).
+For example, it is not possible to overload @atan@ for both one and two arguments;
+instead the names @atan@ and @atan2@ are required.
+The key observation is that only a restricted set of type-generic macros are provided for a limited set of routine names, which do not generalize across the type system, as in \CFA.
+
+
+\subsection{Standard}
+
+C library @stdlib.h@ provides many general routines.
+\CFA routine overloading is used to condense these utility routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+unsigned int `abs`( int );
+double `abs`( double );
+double abs( double _Complex );
+\end{cfa}
+&
+\begin{cfa}
+unsigned int i = `abs`( -1 );
+double d = `abs`( -1.5 );
+double d = `abs`( -1.5+0.5I );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access utility routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+abs
+strto
+random
+\end{cfa}
+&
+\begin{cfa}
+abs, labs, llabs, fabsf, fabs, fabsl, cabsf, cabs, cabsl
+strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold
+srand48, mrand48, lrand48, drand48
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+In additon, there are polymorphic routines, like @min@ and @max@, which work on any type with operators @?<?@ or @?>?@.
+
+The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety.
+C/\Celeven provide a number of complex and overlapping storage-management operation to support the following capabilities:
+\begin{description}[itemsep=2pt,parsep=0pt]
+\item[fill]
+after allocation the storage is filled with a specified character.
+\item[resize]
+an existing allocation is decreased or increased in size.
+In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
+For an increase in storage size, new storage after the copied data may be filled.
+\item[alignment]
+an allocation starts on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes.
+\item[array]
+the allocation size is scaled to the specified number of array elements.
+An array may be filled, resized, or aligned.
+\end{description}
+Table~\ref{t:StorageManagementOperations} shows the capabilities provided by C/\Celeven allocation-routines and how all the capabilities can be combined into two \CFA routines.
+
+\CFA storage-management routines extend the C equivalents by overloading, providing shallow type-safety, and removing the need to specify the base allocation-size.
+The following example contrasts \CFA and C storage-allocation operation performing the same operations with the same type safety:
+\begin{cquote}
+\begin{cfa}[aboveskip=0pt]
+size_t  dim = 10;                                                       $\C{// array dimension}$
+char fill = '\xff';                                                     $\C{// initialization fill value}$
+int * ip;
+\end{cfa}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+ip = alloc();
+ip = alloc( fill );
+ip = alloc( dim );
+ip = alloc( dim, fill );
+ip = alloc( ip, 2 * dim );
+ip = alloc( ip, 4 * dim, fill );
+
+ip = align_alloc( 16 );
+ip = align_alloc( 16, fill );
+ip = align_alloc( 16, dim );
+ip = align_alloc( 16, dim, fill );
+\end{cfa}
+&
+\begin{cfa}
+ip = (int *)malloc( sizeof( int ) );
+ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) );
+ip = (int *)malloc( dim * sizeof( int ) );
+ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
+ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
+ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
+
+ip = memalign( 16, sizeof( int ) );
+ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
+ip = memalign( 16, dim * sizeof( int ) );
+ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Variadic @new@ (see Section~\ref{sec:variadic-tuples}) cannot support the same overloading because extra parameters are for initialization.
+Hence, there are @new@ and @anew@ routines for single and array variables, and the fill value is the arguments to the constructor, \eg:
+\begin{cfa}
+struct S { int i, j; };
+void ?{}( S & s, int i, int j ) { s.i = i; s.j = j; }
+S * s = new( 2, 3 );                                            $\C{// allocate storage and run constructor}$
+S * as = anew( dim, 2, 3 );                                     $\C{// each array element initialized to 2, 3}$
+\end{cfa}
+Note, \CC can only initialization array elements via the default constructor.
+
+Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap.
+When a @realloc@ is performed, the sticky properties are respected, so that new storage is correctly aligned and initialized with the fill character.
+
+\begin{table}
+\centering
+\lstDeleteShortInline@%
+\lstMakeShortInline~%
+\begin{tabular}{@{}r|r|l|l|l|l@{}}
+\multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
+\hline
+C               & ~malloc~                      & no                    & no            & no            & no    \\
+                & ~calloc~                      & yes (0 only)  & no            & no            & yes   \\
+                & ~realloc~                     & no/copy               & yes           & no            & no    \\
+                & ~memalign~            & no                    & no            & yes           & no    \\
+                & ~posix_memalign~      & no                    & no            & yes           & no    \\
+\hline
+C11             & ~aligned_alloc~       & no                    & no            & yes           & no    \\
+\hline
+\CFA    & ~alloc~                       & yes/copy              & no/yes        & no            & yes   \\
+                & ~align_alloc~         & yes                   & no            & yes           & yes   \\
+\end{tabular}
+\lstDeleteShortInline~%
+\lstMakeShortInline@%
+\caption{Storage-Management Operations}
+\label{t:StorageManagementOperations}
+\end{table}
+
+
+\subsection{I/O}
+\label{s:IOLibrary}
+
+The goal of \CFA I/O is to simplify the common cases, while fully supporting polymorphism and user defined types in a consistent way.
+The approach combines ideas from \CC and Python.
+The \CFA header file for the I/O library is @fstream@.
+
+The common case is printing out a sequence of variables separated by whitespace.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{cfa}
+int x = 1, y = 2, z = 3;
+sout | x `|` y `|` z | endl;
+\end{cfa}
+&
+\begin{cfa}
+
+cout << x `<< " "` << y `<< " "` << z << endl;
+\end{cfa}
+\\
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+1` `2` `3
+\end{cfa}
+&
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+1 2 3
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The \CFA form has half the characters of the \CC form, and is similar to Python I/O with respect to implicit separators.
+Similar simplification occurs for tuple I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
+\begin{cfa}
+[int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
+sout | t1 | t2 | endl;                                  $\C{// print tuples}$
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+1`, `2`, `3 4`, `5`, `6
+\end{cfa}
+Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
+Therefore, fewer output expressions require parenthesis.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}ll@{}}
+\textbf{\CFA:}
+&
+\begin{cfa}
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+\end{cfa}
+\\
+\textbf{\CC:}
+&
+\begin{cfa}
+cout << x * 3 << y + 1 << `(`z << 2`)` << `(`x == y`)` << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{cfa}
+\\
+\textbf{output:}
+&
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+3 3 12 0 3 1 2
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
+
+The implicit separator character (space/blank) is a separator not a terminator.
+The rules for implicitly adding the separator are:
+\begin{itemize}[itemsep=2pt,parsep=0pt]
+\item
+A separator does not appear at the start or end of a line.
+\item
+A separator does not appear before or after a character literal or variable.
+\item
+A separator does not appear before or after a null (empty) C string, which is a local mechanism to disable insertion of the separator character.
+\item
+A separator does not appear before a C string starting with the characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$@
+\item
+A seperator does not appear after a C string ending with the characters: \lstinline[basicstyle=\tt]@,.;!?)]}%@
+\item
+{\lstset{language=CFA,deletedelim=**[is][]{`}{`}}
+A seperator does not appear before or after a C string begining/ending with the quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
+}%
+\item
+There are routines to set and get the separator string, and manipulators to toggle separation on and off in the middle of output.
+\end{itemize}
+
+
+\subsection{Multi-precision Integers}
+\label{s:MultiPrecisionIntegers}
+
+\CFA has an interface to the GMP multi-precision signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP.
+The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers.
+The \CFA type name for multi-precision signed-integers is @Int@ and the header file is @gmp@.
+The following multi-precision factorial programs contrast using GMP with the \CFA and C interfaces.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\begin{cfa}
+#include <gmp>
+int main( void ) {
+        sout | "Factorial Numbers" | endl;
+        Int fact = 1;
+
+        sout | 0 | fact | endl;
+        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+                fact *= i;
+                sout | i | fact | endl;
+        }
+}
+\end{cfa}
+&
+\begin{cfa}
+#include <gmp.h>
+int main( void ) {
+        `gmp_printf`( "Factorial Numbers\n" );
+        `mpz_t` fact;
+        `mpz_init_set_ui`( fact, 1 );
+        `gmp_printf`( "%d %Zd\n", 0, fact );
+        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+                `mpz_mul_ui`( fact, fact, i );
+                `gmp_printf`( "%d %Zd\n", i, fact );
+        }
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+
 
 \section{Evaluation}
@@ -1704 +2323 @@
 
 \begin{table}
+\centering
 \caption{Properties of benchmark code}
 \label{tab:eval}

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Wed Jan 31 22:29:25 2018
-%% Update Count     : 3147
+%% Last Modified On : Tue Feb 13 08:31:21 2018
+%% Update Count     : 3161
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -161 +161 @@
 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{quote2}
+\begin{cquote}
 \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{quote2}
+\end{cquote}
 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}).
 
@@ -274 +274 @@
 
 \begin{comment}
-A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating-point array:
+A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating array:
 \begin{lstlisting}
 void * bsearch( const void * key, const void * base, size_t dim, size_t size,
@@ -282 +282 @@
                                 *(double *)t2 < *(double *)t1 ? 1 : 0; }
 
-double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
+double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
 \end{lstlisting}
@@ -444 +444 @@
 0x®_®ff®_®ff;                                                   §\C{// hexadecimal constant}§
 0x®_®ef3d®_®aa5c;                                               §\C{// hexadecimal constant}§
-3.141®_®592®_®654;                                              §\C{// floating point constant}§
-10®_®e®_®+1®_®00;                                               §\C{// floating point constant}§
-0x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating point}§
-0x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating point long 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}
@@ -501 +501 @@
 \label{f:HeaderFileInterposition}
 \end{figure}
+
+
+\section{Exponentiation Operator}
+
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
+
+As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
+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©.
+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©;
+for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
 
 
@@ -628 +649 @@
 \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{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \begin{cfa}
@@ -656 +677 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\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.
@@ -730 +751 @@
         ®int y = 1;®                            §\C{// unreachable initialization}§
         ®x = 7;®                                        §\C{// unreachable code without label/branch}§
-  case 3: ...
+  case 0: ...
         ...
         ®int z = 0;®                            §\C{// unreachable initialization, cannot appear after case}§
         z = 2;
-  case 3:
+  case 1:
         ®x = z;®                                        §\C{// without fall through, z is uninitialized}§
 }
@@ -819 +840 @@
 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{quote2}
+\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}} \\
@@ -849 +870 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 In addition, two forms of subranges are allowed to specify case values: a new \CFA form and an existing GNU C form.\footnote{
 The GNU C form \emph{requires} spaces around the ellipse.}
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}}     \\
@@ -882 +903 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 Lists of subranges are also allowed.
 \begin{cfa}
@@ -902 +923 @@
 }
 \end{C++}
-Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
+Since \CFA is non-object-oriented, the equivalent object-oriented program looks like:
 \begin{cfa}
 struct S { int i, j; };
-int mem( S &®this® ) {                  §\C{// explicit "this" parameter}§
+int mem( S & ®this® ) {                 §\C{// explicit "this" parameter}§
         ®this.®i = 1;                           §\C{// "this" is not elided}§
         ®this.®j = 2;
 }
 \end{cfa}
-but it is cumbersome having to write "©this.©" many times in a member.
+but it is cumbersome having to write ``©this.©'' many times in a member.
 
 \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}
@@ -922 +943 @@
 \begin{cfa}
 struct T { double m, n; };
-int mem2( S &this1, T &this2 ) ®with this1, this2® {
+int mem2( S & this1, T & this2 ) ®with this1, this2® {
         i = 1; j = 2;
         m = 1.0; n = 2.0;
@@ -933 +954 @@
         struct S1 { ... } s1;
         struct S2 { ... } s2;
-        ®with s1® {                     // with statement
+        ®with s1® {                                     §\C{// with statement}§
                 // access fields of s1 without qualification
-                ®with s2® {  // nesting
+                ®with s2® {                             §\C{// nesting}§
                         // access fields of s1 and s2 without qualification
                 }
@@ -1045 +1066 @@
 
 
-\section{Declarations}
-\label{s:Declarations}
+\section{Alternative Declarations}
+\label{s:AlternativeDeclarations}
 
 C declaration syntax is notoriously confusing and error prone.
 For example, many C programmers are confused by a declaration as simple as:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{}}
 \begin{cfa}
@@ -1058 +1079 @@
 \raisebox{-0.75\totalheight}{\input{Cdecl}}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 Is this an array of 5 pointers to integers or a \Index{pointer} to an array of 5 integers?
-The fact this declaration is unclear to many C programmers means there are \Index{productivity} and \Index{safety} issues even for basic programs.
+If there is any doubt, it implies \Index{productivity} and \Index{safety} issues even for basic programs.
 Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
-int ®(*®f®())[®5®]® {...};                              §\C{definition}§
- ... ®(*®f®())[®3®]® += 1;                              §\C{usage}§
+int ®(*®f®())[®5®]® {...};                              §\C{// definition}§
+ ... ®(*®f®())[®3®]® += 1;                              §\C{// usage}§
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
@@ -1074 +1095 @@
 In the following example, \R{red} is the base type and \B{blue} is qualifiers.
 The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
@@ -1089 +1110 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 The only exception is \Index{bit field} specification, which always appear to the right of the base type.
 % Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
 For instance, variables ©x© and ©y© of type \Index{pointer} to integer are defined in \CFA as follows:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
@@ -1105 +1126 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 The downside of this semantics is the need to separate regular and \Index{pointer} declarations:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
@@ -1120 +1141 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 which is \Index{prescribing} a safety benefit.
 Other examples are:
-\begin{quote2}
+\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}} \\
@@ -1159 +1180 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
@@ -1180 +1201 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 All declaration qualifiers, \eg ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} \eg:
-\begin{quote2}
+\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}} \\
@@ -1201 +1222 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
-y = (®* int®)x;
-i = sizeof(®[ 5 ] * int®);
+y = (* int)x;
+i = sizeof([ 5 ] * int);
 \end{cfa}
 &
 \begin{cfa}
-y = (®int *®)x;
-i = sizeof(®int * [ 5 ]®);
+y = (int *)x;
+i = sizeof(int * [ 5 ]);
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
-Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
-
-
-\section{Exponentiation Operator}
-
-C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
-\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
-The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
-
-As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
-Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is optimized to $O(\log y)$.} (or shifting if the base is 2).
-Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $x^{-y}=1/x^y$.
-Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
-Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
-\begin{cfa}
-sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
-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©.
-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©;
-for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
+Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
 
 
@@ -1260 +1260 @@
 A program \newterm{object} is a region of data storage in the execution environment, the contents of which can represent values.
 In most cases, objects are located in memory at an address, and the variable name for an object is an implicit address to the object generated by the compiler and automatically dereferenced, as in:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{\hspace{2em}}l@{}}
 \begin{cfa}
@@ -1278 +1278 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 where the right example is how the compiler logically interprets the variables in the left example.
 Since a variable name only points to one address during its lifetime, it is an \Index{immutable} \Index{pointer};
@@ -1284 +1284 @@
 In general, variable addresses are stored in instructions instead of loaded from memory, and hence may not occupy storage.
 These approaches are contrasted in the following:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l|l@{}}
 \multicolumn{1}{c|}{explicit variable address} & \multicolumn{1}{c}{implicit variable address} \\
@@ -1302 +1302 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 Finally, the immutable nature of a variable's address and the fact that there is no storage for the variable pointer means pointer assignment\index{pointer!assignment}\index{assignment!pointer} is impossible.
 Therefore, the expression ©x = y© has only one meaning, ©*x = *y©, \ie manipulate values, which is why explicitly writing the dereferences is unnecessary even though it occurs implicitly as part of \Index{instruction decoding}.
@@ -1309 +1309 @@
 (Similarly, an integer variable can contain multiple integer literals during its lifetime versus an integer constant representing a single literal during its lifetime, and like a variable name, may not occupy storage if the literal is embedded directly into instructions.)
 Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, \eg:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
 \begin{cfa}
@@ -1321 +1321 @@
 \raisebox{-0.5\totalheight}{\input{pointer2.pstex_t}}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 Notice, an address has a \Index{duality}\index{address!duality}: a location in memory or the value at that location.
@@ -1426 +1426 @@
 The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
 The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
-\CFA-style declarations (see \VRef{s:Declarations}) attempt to address this issue:
-\begin{quote2}
+\CFA-style declarations (see \VRef{s:AlternativeDeclarations}) attempt to address this issue:
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
@@ -1440 +1440 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 where the \CFA declaration is read left-to-right.
 
@@ -1518 +1518 @@
 \begin{cfa}
 void f( int i );
-void (*fp)( int );                                      §\C{// routine pointer}§
+void (* fp)( int );                                     §\C{// routine pointer}§
 fp = f;                                                         §\C{// reference initialization}§
 fp = &f;                                                        §\C{// pointer initialization}§
@@ -1897 +1897 @@
 \end{cfa}
 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
-Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), \eg:
+Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:AlternativeDeclarations}), \eg:
 \begin{cfa}
 C :             const double bar1(), bar2( int ), bar3( double );
@@ -2072 +2072 @@
 Default arguments and overloading (see Section 24) are complementary.
 While in theory default arguments can be simulated with overloading, as in:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}}   & \multicolumn{1}{c}{\textbf{overloading}}      \\
@@ -2087 +2087 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 the number of required overloaded routines is linear in the number of default values, which is unacceptable growth.
 In general, overloading should only be used over default arguments if the body of the routine is significantly different.
@@ -2224 +2224 @@
 The following program in undefined in \CFA (and Indexc{gcc})
 \begin{cfa}
-[* [int]( int )] foo() {                §\C{// int (*foo())( int )}§
+[* [int]( int )] foo() {                §\C{// int (* foo())( int )}§
         int ®i® = 7;
         int bar( int p ) {
@@ -2233 +2233 @@
 }
 int main() {
-        * [int]( int ) fp = foo();      §\C{// int (*fp)( int )}§
+        * [int]( int ) fp = foo();      §\C{// int (* fp)( int )}§
         sout | fp( 3 ) | endl;
 }
@@ -2272 +2272 @@
 In the latter approach, additional return values are passed as pointer parameters.
 A pointer parameter is assigned inside the routine to emulate a return.
-For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating-point value.
+For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
 \begin{cfa}
 double modf( double x, double * i );            §\C{// from include math.h}§
@@ -2995 +2995 @@
 
 The common case is printing out a sequence of variables separated by whitespace.
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
@@ -3016 +3016 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators.
 Similar simplification occurs for \Index{tuple} I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
@@ -3028 +3028 @@
 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
 Therefore, fewer output expressions require parenthesis.
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{}}
 \textbf{\CFA:}
@@ -3047 +3047 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
 
@@ -3420 +3420 @@
         int id;
         float size;
-        Parts *optionalParts;
+        Parts * optionalParts;
 };
 
@@ -3634 +3634 @@
 
 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization ex\-pression type.
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}ll@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CC}} & \multicolumn{1}{c}{\textbf{\Indexc{gcc}}} \\
@@ -3658 +3658 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 The two important capabilities are:
 \begin{itemize}
@@ -3806 +3806 @@
 
 generic(type T)
-typedef int (*predicate)(T);
+typedef int (* predicate)(T);
 generic(type Captured, type T)
-typedef void (*callback)(Captured, T);
+typedef void (* callback)(Captured, T);
 
 generic(type T)
-void find(int length, T *array,
+void find(int length, T * array,
         predicate(T) p, callback(void *, T)f) {
         int i;
@@ -3835 +3835 @@
 struct LinkedListElem {
         T elem;
-        LinkedListElem(T) *next;
+        LinkedListElem(T) * next;
 };
 
-LinkedListElem *++?(LinkedListElem **elem) {
-        return *elem = elem->next;
+LinkedListElem *++?(LinkedListElem ** elem) {
+        return * elem = elem->next;
 }
 
 generic (type T)
 struct LinkedList {
-        LinkedListElem(T) *head;
+        LinkedListElem(T) * head;
         unsigned int size;
 }
 
 generic (type T | bool ?==?(T, T))
-bool contains(LinkedList(T) *list, T elem) {
-        for(LinkedListElem *iter = list->head; iter != 0; ++iter) {
+bool contains(LinkedList(T) * list, T elem) {
+        for(LinkedListElem * iter = list->head; iter != 0; ++iter) {
         if (iter->elem == elem) return true;
         }
@@ -4063 +4063 @@
 // transferring requires mutual exclusion and calls deleteJob
 
-void transferJob(mutex Worker &from, Worker &to) {
+void transferJob(mutex Worker & from, Worker & to) {
         ...
         deleteJob(j);
@@ -5001 +5001 @@
 #include <unistd.h>
 }
-size_t fileSize( const char *path ) {
+size_t fileSize( const char * path ) {
         struct stat s;
         stat(path, &s);
@@ -5038 +5038 @@
 #[link(name = "libc")]
 extern {
-        fn stat(path: *const u8,
-        buf: *mut stat_t) -> c_int;
-}
-fn fileSize(path: *const u8) -> size_t
+        fn stat(path: * const u8,
+        buf: * mut stat_t) -> c_int;
+}
+fn fileSize(path: * const u8) -> size_t
 {
         unsafe {
@@ -5063 +5063 @@
 generic(type T, type N |
         { int ?<?(N, N); })
-T *maximize(N (*f)(const T&),
+T * maximize(N (*f)(const T&),
         int n, T *a) {
-        T *bestX = NULL;
+        T * bestX = NULL;
         N bestN;
         for (int i = 0; i < n; i++) {
@@ -5077 +5077 @@
 }
 
-string *longest(int n, string *p)
+string * longest(int n, string *p)
 {
         return maximize(length, n, p);
@@ -5085 +5085 @@
 \begin{cfa}
 template<typename T, typename F>
-T *maximize(const F &f,
+T * maximize(const F &f,
         int n, T *a) {
         typedef decltype(f(a[0])) N;
-        T *bestX = NULL;
+        T * bestX = NULL;
         N bestN;
         for (int i = 0; i < n; i++) {
@@ -5100 +5100 @@
 }
 
-string *longest(int n, string *p) {
+string * longest(int n, string *p) {
         return maximize(
         [](const string &s) {
@@ -5258 +5258 @@
 \begin{cfa}
 task Nonzero {
-        int *data;
+        int * data;
         int start;
         int end;
@@ -5721 +5721 @@
 \CFA introduces the following new keywords.
 
-\begin{quote2}
+\begin{cquote}
 \input{../refrat/keywords}
-\end{quote2}
+\end{cquote}
 
 
@@ -5730 +5730 @@
 
 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}llllll|l@{}}
 \multicolumn{6}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
@@ -5790 +5790 @@
 \end{tabular}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
@@ -6531 +6531 @@
 The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
-\begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
 \multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
@@ -6563 +6563 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 \begin{figure}

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 21 11:32:56 2017
-// Update Count     : 2996
+// Last Modified On : Tue Feb 13 11:40:34 2018
+// Update Count     : 2999
 //
 
@@ -482 +482 @@
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
-                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
+                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
-                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
+                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
         ;
 
@@ -767 +767 @@
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+        | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
+                { $$ = nullptr; }
         ;
 
@@ -1050 +1052 @@
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
+        | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
+                { $$ = nullptr; }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }

src/tests/alloc.c

@@ -10 +10 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 22 21:26:40 2018
-// Update Count     : 326
+// Last Modified On : Wed Feb 14 17:52:36 2018
+// Update Count     : 328
 //
 
@@ -27 +27 @@
 int main( void ) {
         size_t dim = 10;
+        char fill = '\xff';
         int * p;
-        char fill = '\1';
 
         // allocation, non-array types