Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision 23c27039d154516f4cb778bd20b2ac74a513ba2e)
+++ doc/user/user.tex	(revision f1917fb9af44421f08b63da0a9149e7f406d6842)
@@ -11,6 +11,6 @@
 %% 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,5 +161,5 @@
 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,5 +191,5 @@
 \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,5 +274,5 @@
 
 \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,5 +282,5 @@
 				*(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,8 +444,8 @@
 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,4 +501,25 @@
 \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,5 +649,5 @@
 \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,5 +677,5 @@
 \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,9 +751,9 @@
 	®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,5 +840,5 @@
 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,8 +870,8 @@
 \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,5 +903,5 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 Lists of subranges are also allowed.
 \begin{cfa}
@@ -902,19 +923,19 @@
 }
 \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,5 +943,5 @@
 \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,7 +954,7 @@
 	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,10 +1066,10 @@
 
 
-\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,12 +1079,12 @@
 \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,5 +1095,5 @@
 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,10 +1110,10 @@
 \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,7 +1126,7 @@
 \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,8 +1141,8 @@
 \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,8 +1180,8 @@
 \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,8 +1201,8 @@
 \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,46 +1222,25 @@
 \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,5 +1260,5 @@
 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,5 +1278,5 @@
 \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,5 +1284,5 @@
 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,5 +1302,5 @@
 \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,5 +1309,5 @@
 (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,5 +1321,5 @@
 \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,6 +1426,6 @@
 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,5 +1440,5 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 where the \CFA declaration is read left-to-right.
 
@@ -1518,5 +1518,5 @@
 \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,5 +1897,5 @@
 \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,5 +2072,5 @@
 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,5 +2087,5 @@
 \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,5 +2224,5 @@
 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,5 +2233,5 @@
 }
 int main() {
-	* [int]( int ) fp = foo();	§\C{// int (*fp)( int )}§
+	* [int]( int ) fp = foo();	§\C{// int (* fp)( int )}§
 	sout | fp( 3 ) | endl;
 }
@@ -2272,5 +2272,5 @@
 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,5 +2995,5 @@
 
 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,5 +3016,5 @@
 \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,5 +3028,5 @@
 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,5 +3047,5 @@
 \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,5 +3420,5 @@
 	int id;
 	float size;
-	Parts *optionalParts;
+	Parts * optionalParts;
 };
 
@@ -3634,5 +3634,5 @@
 
 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,5 +3658,5 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 The two important capabilities are:
 \begin{itemize}
@@ -3806,10 +3806,10 @@
 
 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,20 +3835,20 @@
 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,5 +4063,5 @@
 // transferring requires mutual exclusion and calls deleteJob
 
-void transferJob(mutex Worker &from, Worker &to) {
+void transferJob(mutex Worker & from, Worker & to) {
 	...
 	deleteJob(j);
@@ -5001,5 +5001,5 @@
 #include <unistd.h>
 }
-size_t fileSize( const char *path ) {
+size_t fileSize( const char * path ) {
 	struct stat s;
 	stat(path, &s);
@@ -5038,8 +5038,8 @@
 #[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,7 +5063,7 @@
 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,5 +5077,5 @@
 }
 
-string *longest(int n, string *p)
+string * longest(int n, string *p)
 {
 	return maximize(length, n, p);
@@ -5085,8 +5085,8 @@
 \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,5 +5100,5 @@
 }
 
-string *longest(int n, string *p) {
+string * longest(int n, string *p) {
 	return maximize(
 	[](const string &s) {
@@ -5258,5 +5258,5 @@
 \begin{cfa}
 task Nonzero {
-	int *data;
+	int * data;
 	int start;
 	int end;
@@ -5721,7 +5721,7 @@
 \CFA introduces the following new keywords.
 
-\begin{quote2}
+\begin{cquote}
 \input{../refrat/keywords}
-\end{quote2}
+\end{cquote}
 
 
@@ -5730,5 +5730,5 @@
 
 \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,5 +5790,5 @@
 \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,5 +6531,5 @@
 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,5 +6563,5 @@
 \end{cfa}
 \end{tabular}
-\end{quote2}
+\end{cquote}
 
 \begin{figure}
