Changeset 9e0a360

Timestamp:

Jun 23, 2019, 11:46:19 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

397edf7, 54dd994, 70a141d4, c1ea11b

Parents:

e764ee1

Message:

rewrite iostream section, add more manipulator, formatting

File:

• doc/user/user.tex (modified) (146 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sun May  5 18:24:50 2019
-%% Update Count     : 3489
+%% Last Modified On : Sat Jun 15 16:29:45 2019
+%% Update Count     : 3847
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -254 +254 @@
 \begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
-int forty_two = identity( 42 );                         §\C{// T is bound to int, forty\_two == 42}§
+int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§
 \end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
@@ -282 +282 @@
 
 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}§
+double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§
 \end{lstlisting}
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
@@ -291 +291 @@
 
 forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
-        T * result = bsearch( key, arr, size ); §\C{// call first version}§
-        return result ? result - arr : size; }  §\C{// pointer subtraction includes sizeof(T)}§
-
-double * val = bsearch( 5.0, vals, 10 );        §\C{// selection based on return type}§
+        T * result = bsearch( key, arr, size ); §\C{// call first version}§
+        return result ? result - arr : size; } §\C{// pointer subtraction includes sizeof(T)}§
+
+double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§
 int posn = bsearch( 5.0, vals, 10 );
 \end{lstlisting}
@@ -306 +306 @@
 \begin{lstlisting}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
-int * ip = malloc();                                            §\C{// select type and size from left-hand side}§
+int * ip = malloc(); §\C{// select type and size from left-hand side}§
 double * dp = malloc();
 struct S {...} * sp = malloc();
@@ -318 +318 @@
 \begin{cfa}
 char ®abs®( char );
-extern "C" { int ®abs®( int ); }                        §\C{// use default C routine for int}§
+extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§
 long int ®abs®( long int );
 long long int ®abs®( long long int );
@@ -426 +426 @@
 \begin{cfa}
 #ifndef __CFORALL__
-#include <stdio.h>§\indexc{stdio.h}§            §\C{// C header file}§
+#include <stdio.h>§\indexc{stdio.h}§ §\C{// C header file}§
 #else
-#include <fstream>§\indexc{fstream}§            §\C{// \CFA header file}§
+#include <fstream>§\indexc{fstream}§ §\C{// \CFA header file}§
 #endif
 \end{cfa}
@@ -512 +512 @@
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
-int ®`®otype®`® = 3;                                            §\C{// make keyword an identifier}§
+int ®`®otype®`® = 3; §\C{// make keyword an identifier}§
 double ®`®forall®`® = 3.5;
 \end{cfa}
@@ -523 +523 @@
 \begin{cfa}
 // include file uses the CFA keyword "with".
-#if ! defined( with )                                           §\C{// nesting ?}§
-#define with ®`®with®`®                                         §\C{// make keyword an identifier}§
+#if ! defined( with ) §\C{// nesting ?}§
+#define with ®`®with®`® §\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
 #endif
 
-®#include_next <bfdlink.h>                      §\C{// must have internal check for multiple expansion}§
+®#include_next <bfdlink.h> §\C{// must have internal check for multiple expansion}§
 ®
 #if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
@@ -544 +544 @@
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
 \begin{cfa}
-2®_®147®_®483®_®648;                                            §\C{// decimal constant}§
-56®_®ul;                                                                        §\C{// decimal unsigned long constant}§
-0®_®377;                                                                        §\C{// octal constant}§
-0x®_®ff®_®ff;                                                           §\C{// hexadecimal constant}§
-0x®_®ef3d®_®aa5c;                                                       §\C{// hexadecimal constant}§
-3.141®_®592®_®654;                                                      §\C{// floating constant}§
-10®_®e®_®+1®_®00;                                                       §\C{// floating constant}§
-0x®_®ff®_®ff®_®p®_®3;                                           §\C{// hexadecimal floating}§
-0x®_®1.ffff®_®ffff®_®p®_®128®_®l;                       §\C{// hexadecimal floating long constant}§
-L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
+2®_®147®_®483®_®648; §\C{// decimal constant}§
+56®_®ul; §\C{// decimal unsigned long constant}§
+0®_®377; §\C{// octal constant}§
+0x®_®ff®_®ff; §\C{// hexadecimal constant}§
+0x®_®ef3d®_®aa5c; §\C{// hexadecimal constant}§
+3.141®_®592®_®654; §\C{// floating constant}§
+10®_®e®_®+1®_®00; §\C{// floating constant}§
+0x®_®ff®_®ff®_®p®_®3; §\C{// hexadecimal floating}§
+0x®_®1.ffff®_®ffff®_®p®_®128®_®l; §\C{// hexadecimal floating long constant}§
+L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§; §\C{// wide character constant}§
 \end{cfa}
 The rules for placement of underscores are:
@@ -612 +612 @@
 (Does not make sense for ©do©-©while©.)
 \begin{cfa}
-if ( ®int x = f()® ) ...                                        §\C{// x != 0}§
-if ( ®int x = f(), y = g()® ) ...                       §\C{// x != 0 \&\& y != 0}§
-if ( ®int x = f(), y = g(); x < y® ) ...        §\C{// relational expression}§
+if ( ®int x = f()® ) ... §\C{// x != 0}§
+if ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§
+if ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
 if ( ®struct S { int i; } x = { f() }; x.i < 4® ) §\C{// relational expression}§
 
-while ( ®int x = f()® ) ...                                     §\C{// x != 0}§
-while ( ®int x = f(), y = g()® ) ...            §\C{// x != 0 \&\& y != 0}§
+while ( ®int x = f()® ) ... §\C{// x != 0}§
+while ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§
 while ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
 while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... §\C{// relational expression}§
@@ -892 +892 @@
 \begin{cfa}
 switch ( x ) {
-        ®int y = 1;®                                                    §\C{// unreachable initialization}§
-        ®x = 7;®                                                                §\C{// unreachable code without label/branch}§
+        ®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}§
+        ®int z = 0;® §\C{// unreachable initialization, cannot appear after case}§
         z = 2;
   case 1:
-        ®x = z;®                                                                §\C{// without fall through, z is uninitialized}§
+        ®x = z;® §\C{// without fall through, z is uninitialized}§
 }
 \end{cfa}
@@ -937 +937 @@
   ®case 5:
         ...
-        ®fallthru®;                                                             §\C{// explicit fall through}§
+        ®fallthru®; §\C{// explicit fall through}§
   case 7:
         ...
-        ®break®                                                                 §\C{// explicit end of switch (redundant)}§
+        ®break® §\C{// explicit end of switch (redundant)}§
   default:
         j = 3;
@@ -961 +961 @@
 \begin{cfa}
 switch ( x ) {
-        ®int i = 0;®                                                    §\C{// allowed only at start}§
+        ®int i = 0;® §\C{// allowed only at start}§
   case 0:
         ...
-        ®int j = 0;®                                                    §\C{// disallowed}§
+        ®int j = 0;® §\C{// disallowed}§
   case 1:
         {
-                ®int k = 0;®                                            §\C{// allowed at different nesting levels}§
+                ®int k = 0;® §\C{// allowed at different nesting levels}§
                 ...
-          ®case 2:®                                                             §\C{// disallow case in nested statements}§
+          ®case 2:® §\C{// disallow case in nested statements}§
         }
   ...
@@ -1019 +1019 @@
 \begin{cfa}
 switch ( i ) {
-  case ®1~5:®                                   §\C{// 1, 2, 3, 4, 5}§
+  case ®1~5:® §\C{// 1, 2, 3, 4, 5}§
         ...
-  case ®10~15:®                                 §\C{// 10, 11, 12, 13, 14, 15}§
+  case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§
         ...
 }
@@ -1152 +1152 @@
 Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
 \begin{cfa}
-struct S {                                                                      §\C{// aggregate}§
-        char c;                                                                 §\C{// fields}§
+struct S { §\C{// aggregate}§
+        char c; §\C{// fields}§
         int i;
         double d;
@@ -1162 +1162 @@
 \begin{cfa}
 void f( S s ) {
-        ®s.®c; ®s.®i; ®s.®d;                                    §\C{// access containing fields}§
+        ®s.®c; ®s.®i; ®s.®d; §\C{// access containing fields}§
 }
 \end{cfa}
@@ -1169 +1169 @@
 \begin{C++}
 struct S {
-        char c;                                                                 §\C{// fields}§
+        char c; §\C{// fields}§
         int i;
         double d;
-        void f() {                                                              §\C{// implicit ``this'' aggregate}§
-                ®this->®c; ®this->®i; ®this->®d;        §\C{// access containing fields}§
+        void f() { §\C{// implicit ``this'' aggregate}§
+                ®this->®c; ®this->®i; ®this->®d; §\C{// access containing fields}§
         }
 }
@@ -1181 +1181 @@
 \begin{cfa}
 struct T { double m, n; };
-int S::f( T & t ) {                                                     §\C{// multiple aggregate parameters}§
-        c; i; d;                                                                §\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}§
-        ®t.®m; ®t.®n;                                                   §\C{// must qualify}§
+int S::f( T & t ) { §\C{// multiple aggregate parameters}§
+        c; i; d; §\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}§
+        ®t.®m; ®t.®n; §\C{// must qualify}§
 }
 \end{cfa}
@@ -1190 +1190 @@
 Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
 \begin{cfa}
-void f( S & this ) ®with ( this )® {            §\C{// with statement}§
-        c; i; d;                                                                §\C{\color{red}// this.c, this.i, this.d}§
+void f( S & this ) ®with ( this )® { §\C{// with statement}§
+        c; i; d; §\C{\color{red}// this.c, this.i, this.d}§
 }
 \end{cfa}
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
-void f( S & s, T & t ) ®with ( s, t )® {        §\C{// multiple aggregate parameters}§
-        c; i; d;                                                                §\C{\color{red}// s.c, s.i, s.d}§
-        m; n;                                                                   §\C{\color{red}// t.m, t.n}§
+void f( S & s, T & t ) ®with ( s, t )® { §\C{// multiple aggregate parameters}§
+        c; i; d; §\C{\color{red}// s.c, s.i, s.d}§
+        m; n; §\C{\color{red}// t.m, t.n}§
 }
 \end{cfa}
@@ -1220 +1220 @@
 struct T { int ®i®; int k; int m; } t, w;
 with ( s, t ) {
-        j + k;                                                                  §\C{// unambiguous, s.j + t.k}§
-        m = 5.0;                                                                §\C{// unambiguous, t.m = 5.0}§
-        m = 1;                                                                  §\C{// unambiguous, s.m = 1}§
-        int a = m;                                                              §\C{// unambiguous, a = s.i }§
-        double b = m;                                                   §\C{// unambiguous, b = t.m}§
-        int c = s.i + t.i;                                              §\C{// unambiguous, qualification}§
-        (double)m;                                                              §\C{// unambiguous, cast}§
+        j + k; §\C{// unambiguous, s.j + t.k}§
+        m = 5.0; §\C{// unambiguous, t.m = 5.0}§
+        m = 1; §\C{// unambiguous, s.m = 1}§
+        int a = m; §\C{// unambiguous, a = s.i }§
+        double b = m; §\C{// unambiguous, b = t.m}§
+        int c = s.i + t.i; §\C{// unambiguous, qualification}§
+        (double)m; §\C{// unambiguous, cast}§
 }
 \end{cfa}
@@ -1236 +1236 @@
 There is an interesting problem between parameters and the function-body ©with©, \eg:
 \begin{cfa}
-void ?{}( S & s, int i ) with ( s ) {           §\C{// constructor}§
-        ®s.i = i;®  j = 3;  m = 5.5;                    §\C{// initialize fields}§
+void ?{}( S & s, int i ) with ( s ) { §\C{// constructor}§
+        ®s.i = i;®  j = 3;  m = 5.5; §\C{// initialize fields}§
 }
 \end{cfa}
@@ -1256 +1256 @@
 Finally, a cast may be used to disambiguate among overload variables in a ©with© expression:
 \begin{cfa}
-with ( w ) { ... }                                                      §\C{// ambiguous, same name and no context}§
-with ( (S)w ) { ... }                                           §\C{// unambiguous, cast}§
+with ( w ) { ... } §\C{// ambiguous, same name and no context}§
+with ( (S)w ) { ... } §\C{// unambiguous, cast}§
 \end{cfa}
 and ©with© expressions may be complex expressions with type reference (see Section~\ref{s:References}) to aggregate:
 % \begin{cfa}
 % struct S { int i, j; } sv;
-% with ( sv ) {                                                         §\C{// implicit reference}§
+% with ( sv ) { §\C{// implicit reference}§
 %       S & sr = sv;
-%       with ( sr ) {                                                   §\C{// explicit reference}§
+%       with ( sr ) { §\C{// explicit reference}§
 %               S * sp = &sv;
-%               with ( *sp ) {                                          §\C{// computed reference}§
-%                       i = 3; j = 4;                                   §\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}§
+%               with ( *sp ) { §\C{// computed reference}§
+%                       i = 3; j = 4; §\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}§
 %               }
-%               i = 2; j = 3;                                           §\C{\color{red}// sr.i, sr.j}§
+%               i = 2; j = 3; §\C{\color{red}// sr.i, sr.j}§
 %       }
-%       i = 1; j = 2;                                                   §\C{\color{red}// sv.i, sv.j}§
+%       i = 1; j = 2; §\C{\color{red}// sv.i, sv.j}§
 % }
 % \end{cfa}
@@ -1279 +1279 @@
 class C {
         int i, j;
-        int mem() {                                                             §\C{\color{red}// implicit "this" parameter}§
-                i = 1;                                                          §\C{\color{red}// this->i}§
-                j = 2;                                                          §\C{\color{red}// this->j}§
+        int mem() { §\C{\color{red}// implicit "this" parameter}§
+                i = 1; §\C{\color{red}// this->i}§
+                j = 2; §\C{\color{red}// this->j}§
         }
 }
@@ -1288 +1288 @@
 \begin{cfa}
 struct S { int i, j; };
-int mem( S & ®this® ) {                                         §\C{// explicit "this" parameter}§
-        ®this.®i = 1;                                                   §\C{// "this" is not elided}§
+int mem( S & ®this® ) { §\C{// explicit "this" parameter}§
+        ®this.®i = 1; §\C{// "this" is not elided}§
         ®this.®j = 2;
 }
@@ -1297 +1297 @@
 \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}
@@ -1316 +1316 @@
         struct S1 { ... } s1;
         struct S2 { ... } s2;
-        ®with( s1 )® {                                                  §\C{// with statement}§
+        ®with( s1 )® { §\C{// with statement}§
                 // access fields of s1 without qualification
-                ®with s2® {                                                     §\C{// nesting}§
+                ®with s2® { §\C{// nesting}§
                         // access fields of s1 and s2 without qualification
                 }
@@ -1373 +1373 @@
 Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise.
 \begin{cfa}
-exception_t E {};                                                       §\C{// exception type}§
+exception_t E {}; §\C{// exception type}§
 void f(...) {
-        ... throw E{}; ...                                              §\C{// termination}§
-        ... throwResume E{}; ...                                §\C{// resumption}§
+        ... throw E{}; ... §\C{// termination}§
+        ... throwResume E{}; ... §\C{// resumption}§
 }
 try {
@@ -1442 +1442 @@
 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}).
@@ -1635 +1635 @@
 *x = 3;                 // implicit dereference
 int * ®const® y = (int *)104;
-*y = *x;                // implicit dereference
+*y = *x;                        // implicit dereference
 \end{cfa}
 \end{tabular}
@@ -1649 +1649 @@
 \hline
 \begin{cfa}
-lda             r1,100  // load address of x
-ld               r2,(r1)          // load value of x
-lda             r3,104  // load address of y
-st               r2,(r3)          // store x into y
+lda             r1,100   // load address of x
+ld               r2,(r1)   // load value of x
+lda             r3,104   // load address of y
+st               r2,(r3)   // store x into y
 \end{cfa}
 &
 \begin{cfa}
 
-ld              r2,(100)        // load value of x
-
-st              r2,(104)        // store x into y
+ld              r2,(100)   // load value of x
+
+st              r2,(104)   // store x into y
 \end{cfa}
 \end{tabular}
@@ -1673 +1673 @@
 \begin{cfa}
 int x, y, ®*® p1, ®*® p2, ®**® p3;
-p1 = ®&®x;               // p1 points to x
-p2 = p1;                 // p2 points to x
-p1 = ®&®y;               // p1 points to y
-p3 = &p2;               // p3 points to p2
+p1 = ®&®x;     // p1 points to x
+p2 = p1;     // p2 points to x
+p1 = ®&®y;     // p1 points to y
+p3 = &p2;  // p3 points to p2
 \end{cfa}
 &
@@ -1687 +1687 @@
 For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage
 \begin{cfa}
-p2 = p1 + x;                                    §\C{// compiler infers *p2 = *p1 + x;}§
+p2 = p1 + x; §\C{// compiler infers *p2 = *p1 + x;}§
 \end{cfa}
 Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation.
@@ -1695 +1695 @@
 In C, objects of pointer type always manipulate the pointer object's address:
 \begin{cfa}
-p1 = p2;                                                §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§
-p2 = p1 + x;                                    §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§
+p1 = p2; §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§
+p2 = p1 + x; §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§
 \end{cfa}
 even though the assignment to ©p2© is likely incorrect, and the programmer probably meant:
 \begin{cfa}
-p1 = p2;                                                §\C{// pointer address assignment}§
-®*®p2 = ®*®p1 + x;                              §\C{// pointed-to value assignment / operation}§
+p1 = p2; §\C{// pointer address assignment}§
+®*®p2 = ®*®p1 + x; §\C{// pointed-to value assignment / operation}§
 \end{cfa}
 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
@@ -1718 +1718 @@
 \begin{cfa}
 int x, y, ®&® r1, ®&® r2, ®&&® r3;
-®&®r1 = &x;                                             §\C{// r1 points to x}§
-®&®r2 = &r1;                                    §\C{// r2 points to x}§
-®&®r1 = &y;                                             §\C{// r1 points to y}§
-®&&®r3 = ®&®&r2;                                §\C{// r3 points to r2}§
+®&®r1 = &x; §\C{// r1 points to x}§
+®&®r2 = &r1; §\C{// r2 points to x}§
+®&®r1 = &y; §\C{// r1 points to y}§
+®&&®r3 = ®&®&r2; §\C{// r3 points to r2}§
 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); §\C{// implicit dereferencing}§
 \end{cfa}
@@ -1737 +1737 @@
 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
 \begin{cfa}
-(&®*®)r1 = &x;                                  §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§
+(&®*®)r1 = &x; §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§
 \end{cfa}
 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
 \begin{cfa}
-(&(&®*®)®*®)r3 = &(&®*®)r2;             §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§
+(&(&®*®)®*®)r3 = &(&®*®)r2; §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§
 \end{cfa}
 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
@@ -1749 +1749 @@
 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
                  &r1 = x,    &&r2 = r1,   &&&r3 = r2;
-***p3 = 3;                                              §\C{// change x}§
-r3 = 3;                                                 §\C{// change x, ***r3}§
-**p3 = ...;                                             §\C{// change p1}§
-&r3 = ...;                                              §\C{// change r1, (\&*)**r3, 1 cancellation}§
-*p3 = ...;                                              §\C{// change p2}§
-&&r3 = ...;                                             §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§
-&&&r3 = p3;                                             §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§
+***p3 = 3; §\C{// change x}§
+r3 = 3; §\C{// change x, ***r3}§
+**p3 = ...; §\C{// change p1}§
+&r3 = ...; §\C{// change r1, (\&*)**r3, 1 cancellation}§
+*p3 = ...; §\C{// change p2}§
+&&r3 = ...; §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§
+&&&r3 = p3; §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§
 \end{cfa}
 Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types.
@@ -1762 +1762 @@
 As for a pointer type, a reference type may have qualifiers:
 \begin{cfa}
-const int cx = 5;                                       §\C{// cannot change cx;}§
-const int & cr = cx;                            §\C{// cannot change what cr points to}§
-®&®cr = &cx;                                            §\C{// can change cr}§
-cr = 7;                                                         §\C{// error, cannot change cx}§
-int & const rc = x;                                     §\C{// must be initialized}§
-®&®rc = &x;                                                     §\C{// error, cannot change rc}§
-const int & const crc = cx;                     §\C{// must be initialized}§
-crc = 7;                                                        §\C{// error, cannot change cx}§
-®&®crc = &cx;                                           §\C{// error, cannot change crc}§
+const int cx = 5; §\C{// cannot change cx;}§
+const int & cr = cx; §\C{// cannot change what cr points to}§
+®&®cr = &cx; §\C{// can change cr}§
+cr = 7; §\C{// error, cannot change cx}§
+int & const rc = x; §\C{// must be initialized}§
+®&®rc = &x; §\C{// error, cannot change rc}§
+const int & const crc = cx; §\C{// must be initialized}§
+crc = 7; §\C{// error, cannot change cx}§
+®&®crc = &cx; §\C{// error, cannot change crc}§
 \end{cfa}
 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
 \begin{cfa}
-int & const cr = *0;                            §\C{// where 0 is the int * zero}§
+int & const cr = *0; §\C{// where 0 is the int * zero}§
 \end{cfa}
 Note, constant reference-types do not prevent \Index{addressing errors} because of explicit storage-management:
@@ -1781 +1781 @@
 cr = 5;
 free( &cr );
-cr = 7;                                                         §\C{// unsound pointer dereference}§
+cr = 7; §\C{// unsound pointer dereference}§
 \end{cfa}
 
@@ -1806 +1806 @@
 \begin{cfa}
 int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§
-&ar[1] = &w;                                            §\C{// change reference array element}§
-typeof( ar[1] ) p;                                      §\C{// (gcc) is int, \ie the type of referenced object}§
-typeof( &ar[1] ) q;                                     §\C{// (gcc) is int \&, \ie the type of reference}§
-sizeof( ar[1] ) == sizeof( int );       §\C{// is true, \ie the size of referenced object}§
-sizeof( &ar[1] ) == sizeof( int *)      §\C{// is true, \ie the size of a reference}§
+&ar[1] = &w; §\C{// change reference array element}§
+typeof( ar[1] ) p; §\C{// (gcc) is int, \ie the type of referenced object}§
+typeof( &ar[1] ) q; §\C{// (gcc) is int \&, \ie the type of reference}§
+sizeof( ar[1] ) == sizeof( int ); §\C{// is true, \ie the size of referenced object}§
+sizeof( &ar[1] ) == sizeof( int *) §\C{// is true, \ie the size of a reference}§
 \end{cfa}
 
@@ -1827 +1827 @@
 Therefore, for pointer/reference initialization, the initializing value must be an address not a value.
 \begin{cfa}
-int * p = &x;                                           §\C{// assign address of x}§
-®int * p = x;®                                          §\C{// assign value of x}§
-int & r = x;                                            §\C{// must have address of x}§
+int * p = &x; §\C{// assign address of x}§
+®int * p = x;® §\C{// assign value of x}§
+int & r = x; §\C{// must have address of x}§
 \end{cfa}
 Like the previous example with C pointer-arithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given).
@@ -1838 +1838 @@
 Similarly, when a reference type is used for a parameter/return type, the call-site argument does not require a reference operator for the same reason.
 \begin{cfa}
-int & f( int & r );                                     §\C{// reference parameter and return}§
-z = f( x ) + f( y );                            §\C{// reference operator added, temporaries needed for call results}§
+int & f( int & r ); §\C{// reference parameter and return}§
+z = f( x ) + f( y ); §\C{// reference operator added, temporaries needed for call results}§
 \end{cfa}
 Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©.
@@ -1866 +1866 @@
 void f( int & r );
 void g( int * p );
-f( 3 );                   g( ®&®3 );            §\C{// compiler implicit generates temporaries}§
-f( x + y );             g( ®&®(x + y) );        §\C{// compiler implicit generates temporaries}§
+f( 3 );                   g( ®&®3 ); §\C{// compiler implicit generates temporaries}§
+f( x + y );             g( ®&®(x + y) ); §\C{// compiler implicit generates temporaries}§
 \end{cfa}
 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
@@ -1878 +1878 @@
 \begin{cfa}
 void f( int i );
-void (* fp)( int );                                     §\C{// routine pointer}§
-fp = f;                                                         §\C{// reference initialization}§
-fp = &f;                                                        §\C{// pointer initialization}§
-fp = *f;                                                        §\C{// reference initialization}§
-fp(3);                                                          §\C{// reference invocation}§
-(*fp)(3);                                                       §\C{// pointer invocation}§
+void (* fp)( int ); §\C{// routine pointer}§
+fp = f; §\C{// reference initialization}§
+fp = &f; §\C{// pointer initialization}§
+fp = *f; §\C{// reference initialization}§
+fp(3); §\C{// reference invocation}§
+(*fp)(3); §\C{// pointer invocation}§
 \end{cfa}
 While C's treatment of routine objects has similarity to inferring a reference type in initialization contexts, the examples are assignment not initialization, and all possible forms of assignment are possible (©f©, ©&f©, ©*f©) without regard for type.
 Instead, a routine object should be referenced by a ©const© reference:
 \begin{cfa}
-®const® void (®&® fr)( int ) = f;       §\C{// routine reference}§
-fr = ...                                                        §\C{// error, cannot change code}§
-&fr = ...;                                                      §\C{// changing routine reference}§
-fr( 3 );                                                        §\C{// reference call to f}§
-(*fr)(3);                                                       §\C{// error, incorrect type}§
+®const® void (®&® fr)( int ) = f; §\C{// routine reference}§
+fr = ... §\C{// error, cannot change code}§
+&fr = ...; §\C{// changing routine reference}§
+fr( 3 ); §\C{// reference call to f}§
+(*fr)(3); §\C{// error, incorrect type}§
 \end{cfa}
 because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{
@@ -1914 +1914 @@
 int x, * px, ** ppx, *** pppx, **** ppppx;
 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-x = rrrx;               // rrrx is an lvalue with type int &&& (equivalent to x)
-px = &rrrx;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (&x)
-ppx = &&rrrx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (&rx)
-pppx = &&&rrrx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (&rrx)
-ppppx = &&&&rrrx; // starting from &&&rrrx, &&&&rrrx is an rvalue with type int **** (&rrrx)
+x = rrrx; §\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
+px = &rrrx; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}§
+ppx = &&rrrx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}§
+pppx = &&&rrrx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}§
+ppppx = &&&&rrrx; §\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}§
 \end{cfa}
 The following example shows the second rule applied to different \Index{lvalue} contexts:
@@ -1924 +1924 @@
 int x, * px, ** ppx, *** pppx;
 int & rx = x, && rrx = rx, &&& rrrx = rrx ;
-rrrx = 2;               // rrrx is an lvalue with type int &&& (equivalent to x)
-&rrrx = px;             // starting from rrrx, &rrrx is an rvalue with type int *&&& (rx)
-&&rrrx = ppx;   // starting from &rrrx, &&rrrx is an rvalue with type int **&& (rrx)
-&&&rrrx = pppx; // starting from &&rrrx, &&&rrrx is an rvalue with type int ***& (rrrx)
+rrrx = 2; §\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
+&rrrx = px; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}§
+&&rrrx = ppx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}§
+&&&rrrx = pppx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT§
 \end{cfa}
 
@@ -1940 +1940 @@
 \begin{cfa}
 int x;
-x + 1;                  // lvalue variable (int) converts to rvalue for expression
+x + 1; §\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}§
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
@@ -1950 +1950 @@
 \begin{cfa}
 int x, &r = x, f( int p );
-x = ®r® + f( ®r® );  // lvalue reference converts to rvalue
+x = ®r® + f( ®r® ); §\C{// lvalue reference converts to rvalue}§
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
@@ -1957 +1957 @@
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
-int x, &r = ®x®, f( int & p ); // lvalue variable (int) convert to reference (int &)
-f( ®x® );               // lvalue variable (int) convert to reference (int &)
+int x, &r = ®x®, f( int & p ); §\C{// lvalue variable (int) convert to reference (int \&)}§
+f( ®x® ); §\C{// lvalue variable (int) convert to reference (int \&)}§
 \end{cfa}
 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
@@ -1968 +1968 @@
 \begin{cfa}
 int x, & f( int & p );
-f( ®x + 3® );   // rvalue parameter (int) implicitly converts to lvalue temporary reference (int &)
-®&f®(...) = &x; // rvalue result (int &) implicitly converts to lvalue temporary reference (int &)
+f( ®x + 3® );   §\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}§
+®&f®(...) = &x; §\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT§
 \end{cfa}
 In both case, modifications to the temporary are inaccessible (\Index{warning}).
@@ -2158 +2158 @@
 in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in:
 \begin{cfa}
-[§\,§] g();                                                     §\C{// no input or output parameters}§
-[ void ] g( void );                                     §\C{// no input or output parameters}§
+[§\,§] g(); §\C{// no input or output parameters}§
+[ void ] g( void ); §\C{// no input or output parameters}§
 \end{cfa}
 
@@ -2177 +2177 @@
 \begin{cfa}
 typedef int foo;
-int f( int (* foo) );                           §\C{// foo is redefined as a parameter name}§
+int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§
 \end{cfa}
 The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
@@ -2185 +2185 @@
 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
 \begin{cfa}
-[ int ] f( * int, int * );                      §\C{// returns an integer, accepts 2 pointers to integers}§
-[ * int, int * ] f( int );                      §\C{// returns 2 pointers to integers, accepts an integer}§
+[ int ] f( * int, int * ); §\C{// returns an integer, accepts 2 pointers to integers}§
+[ * int, int * ] f( int ); §\C{// returns 2 pointers to integers, accepts an integer}§
 \end{cfa}
 The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in:
 \begin{cfa}
 #define ptoa( n, d ) int (*n)[ d ]
-int f( ptoa( p, 5 ) ) ...                       §\C{// expands to int f( int (*p)[ 5 ] )}§
-[ int ] f( ptoa( p, 5 ) ) ...           §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
+int f( ptoa( p, 5 ) ) ... §\C{// expands to int f( int (*p)[ 5 ] )}§
+[ int ] f( ptoa( p, 5 ) ) ... §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
 \end{cfa}
 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
@@ -2214 +2214 @@
         int z;
         ... x = 0; ... y = z; ...
-        ®return;®                                                       §\C{// implicitly return x, y}§
+        ®return;® §\C{// implicitly return x, y}§
 }
 \end{cfa}
@@ -2224 +2224 @@
 [ int x, int y ] f() {
         ...
-}                                                                               §\C{// implicitly return x, y}§
+} §\C{// implicitly return x, y}§
 \end{cfa}
 In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
@@ -2233 +2233 @@
 [ int x, int y ] f( int, x, int y ) {
         ...
-}                                                                               §\C{// implicitly return x, y}§
+} §\C{// implicitly return x, y}§
 \end{cfa}
 This notation allows the compiler to eliminate temporary variables in nested routine calls.
 \begin{cfa}
-[ int x, int y ] f( int, x, int y );    §\C{// prototype declaration}§
+[ int x, int y ] f( int, x, int y ); §\C{// prototype declaration}§
 int a, b;
 [a, b] = f( f( f( a, b ) ) );
@@ -2251 +2251 @@
 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}§
+[ 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).
@@ -2275 +2275 @@
 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}§
+* [ 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}§
+* [ int x ] f () fp; §\C{// routine name "f" is not allowed}§
 \end{cfa}
 
@@ -2306 +2306 @@
 whereas a named (keyword) call may be:
 \begin{cfa}
-p( z : 3, x : 4, y : 7 );       §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§
+p( z : 3, x : 4, y : 7 );  §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§
 \end{cfa}
 Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters.
@@ -2323 +2323 @@
 For example, the following routine prototypes and definition are all valid.
 \begin{cfa}
-void p( int, int, int );                        §\C{// equivalent prototypes}§
+void p( int, int, int ); §\C{// equivalent prototypes}§
 void p( int x, int y, int z );
 void p( int y, int x, int z );
 void p( int z, int y, int x );
-void p( int q, int r, int s ) {}        §\C{// match with this definition}§
+void p( int q, int r, int s ) {} §\C{// match with this definition}§
 \end{cfa}
 Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming.
@@ -2339 +2339 @@
 int f( int x, double y );
 
-f( j : 3, i : 4 );                              §\C{// 1st f}§
-f( x : 7, y : 8.1 );                    §\C{// 2nd f}§
-f( 4, 5 );                                              §\C{// ambiguous call}§
+f( j : 3, i : 4 ); §\C{// 1st f}§
+f( x : 7, y : 8.1 ); §\C{// 2nd f}§
+f( 4, 5 );  §\C{// ambiguous call}§
 \end{cfa}
 However, named arguments compound routine resolution in conjunction with conversions:
 \begin{cfa}
-f( i : 3, 5.7 );                                §\C{// ambiguous call ?}§
+f( i : 3, 5.7 ); §\C{// ambiguous call ?}§
 \end{cfa}
 Depending on the cost associated with named arguments, this call could be resolvable or ambiguous.
@@ -2359 +2359 @@
 the allowable positional calls are:
 \begin{cfa}
-p();                                                    §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
-p( 4 );                                                 §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
-p( 4, 4 );                                              §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
-p( 4, 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
+p(); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
+p( 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
+p( 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
+p( 4, 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
 // empty arguments
-p(  , 4, 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
-p( 4,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
-p( 4, 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
-p( 4,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
-p(  , 4,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
-p(  ,  , 4 );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
-p(  ,  ,   );                                   §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
+p(  , 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
+p( 4,  , 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
+p( 4, 4,   ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
+p( 4,  ,   ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
+p(  , 4,   ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
+p(  ,  , 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
+p(  ,  ,   ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
 \end{cfa}
 Here the missing arguments are inserted from the default values in the parameter list.
@@ -2394 +2394 @@
 Default values may only appear in a prototype versus definition context:
 \begin{cfa}
-void p( int x, int y = 2, int z = 3 );          §\C{// prototype: allowed}§
-void p( int, int = 2, int = 3 );                        §\C{// prototype: allowed}§
-void p( int x, int y = 2, int z = 3 ) {}        §\C{// definition: not allowed}§
+void p( int x, int y = 2, int z = 3 ); §\C{// prototype: allowed}§
+void p( int, int = 2, int = 3 ); §\C{// prototype: allowed}§
+void p( int x, int y = 2, int z = 3 ) {} §\C{// definition: not allowed}§
 \end{cfa}
 The reason for this restriction is to allow separate compilation.
@@ -2421 +2421 @@
 \begin{cfa}
 void p( int x, int y = 2, int z = 3... );
-p( 1, 4, 5, 6, z : 3 );         §\C{// assume p( /* positional */, ... , /* named */ );}§
-p( 1, z : 3, 4, 5, 6 );         §\C{// assume p( /* positional */, /* named */, ... );}§
+p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
+p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
 \end{cfa}
 The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments;
@@ -2452 +2452 @@
 Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as:
 \begin{cfa}
-p( 1, /* default */, 5 );               §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§
+p( 1, /* default */, 5 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§
 \end{cfa}
 
@@ -2465 +2465 @@
 \begin{cfa}
 struct {
-        int f1;                                 §\C{// named field}§
-        int f2 : 4;                             §\C{// named field with bit field size}§
-        int : 3;                                §\C{// unnamed field for basic type with bit field size}§
-        int ;                                   §\C{// disallowed, unnamed field}§
-        int *;                                  §\C{// disallowed, unnamed field}§
-        int (*)( int );                 §\C{// disallowed, unnamed field}§
+        int f1; §\C{// named field}§
+        int f2 : 4; §\C{// named field with bit field size}§
+        int : 3; §\C{// unnamed field for basic type with bit field size}§
+        int ; §\C{// disallowed, unnamed field}§
+        int *; §\C{// disallowed, unnamed field}§
+        int (*)( int ); §\C{// disallowed, unnamed field}§
 };
 \end{cfa}
@@ -2478 +2478 @@
 \begin{cfa}
 struct {
-        int , , ;                               §\C{// 3 unnamed fields}§
+        int , , ; §\C{// 3 unnamed fields}§
 }
 \end{cfa}
@@ -2572 +2572 @@
 const unsigned int size = 5;
 int ia[size];
-...                                             §\C{// assign values to array ia}§
-qsort( ia, size );              §\C{// sort ascending order using builtin ?<?}§
+... §\C{// assign values to array ia}§
+qsort( ia, size ); §\C{// sort ascending order using builtin ?<?}§
 {
         ®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§
-        qsort( ia, size );      §\C{// sort descending order by local redefinition}§
+        qsort( ia, size ); §\C{// sort descending order by local redefinition}§
 }
 \end{cfa}
@@ -2584 +2584 @@
 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 ) {
-                ®i® += 1;                               §\C{// dependent on local variable}§
+                ®i® += 1; §\C{// dependent on local variable}§
                 sout | ®i®;
         }
-        return bar;                                     §\C{// undefined because of local dependence}§
+        return bar; §\C{// undefined because of local dependence}§
 }
 int main() {
-        * [int]( int ) fp = foo();      §\C{// int (* fp)( int )}§
+        * [int]( int ) fp = foo(); §\C{// int (* fp)( int )}§
         sout | fp( 3 );
 }
@@ -2606 +2606 @@
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 \begin{cfa}
-f( ®2, x, 3 + i® );                             §\C{// element list}§
+f( ®2, x, 3 + i® ); §\C{// element list}§
 \end{cfa}
 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
@@ -2623 +2623 @@
 typedef struct { int quot, rem; } div_t;        §\C[7cm]{// from include stdlib.h}§
 div_t div( int num, int den );
-div_t qr = div( 13, 5 );                                        §\C{// return quotient/remainder aggregate}§
-printf( "%d %d\n", qr.quot, qr.rem );           §\C{// print quotient/remainder}§
+div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§
+printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§
 \end{cfa}
 This approach requires a name for the return type and fields, where \Index{naming} is a common programming-language issue.
@@ -2634 +2634 @@
 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}§
-double intp, frac = modf( 13.5, &intp );        §\C{// return integral and fractional components}§
-printf( "%g %g\n", intp, frac );                        §\C{// print integral/fractional components}§
+double modf( double x, double * i ); §\C{// from include math.h}§
+double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§
+printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§
 \end{cfa}
 This approach requires allocating storage for the return values, which complicates the call site with a sequence of variable declarations leading to the call.
@@ -2663 +2663 @@
 When a function call is passed as an argument to another call, the best match of actual arguments to formal parameters is evaluated given all possible expression interpretations in the current scope.
 \begin{cfa}
-void g( int, int );                                                     §\C{// 1}§
-void g( double, double );                                       §\C{// 2}§
-g( div( 13, 5 ) );                                                      §\C{// select 1}§
-g( modf( 13.5 ) );                                                      §\C{// select 2}§
+void g( int, int ); §\C{// 1}§
+void g( double, double ); §\C{// 2}§
+g( div( 13, 5 ) ); §\C{// select 1}§
+g( modf( 13.5 ) ); §\C{// select 2}§
 \end{cfa}
 In this case, there are two overloaded ©g© routines.
@@ -2675 +2675 @@
 The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call.
 \begin{cfa}
-[ int, int ] div( int x, int y );                       §\C{// from include stdlib}§
-printf( "%d %d\n", div( 13, 5 ) );                      §\C{// print quotient/remainder}§
-
-[ double, double ] modf( double x );            §\C{// from include math}§
-printf( "%g %g\n", modf( 13.5 ) );                      §\C{// print integral/fractional components}§
+[ int, int ] div( int x, int y ); §\C{// from include stdlib}§
+printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§
+
+[ double, double ] modf( double x ); §\C{// from include math}§
+printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§
 \end{cfa}
 This approach provides the benefits of compile-time checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type.
@@ -2689 +2689 @@
 \begin{cfa}
 int quot, rem;
-[ quot, rem ] = div( 13, 5 );                           §\C{// assign multiple variables}§
-printf( "%d %d\n", quot, rem );                         §\C{// print quotient/remainder}\CRT§
+[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§
+printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§
 \end{cfa}
 Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call.
@@ -2716 +2716 @@
 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
 \begin{cfa}
-[int, int] ®qr® = div( 13, 5 );                 §\C{// initialize tuple variable}§
-printf( "%d %d\n", ®qr® );                              §\C{// print quotient/remainder}§
+[int, int] ®qr® = div( 13, 5 ); §\C{// initialize tuple variable}§
+printf( "%d %d\n", ®qr® ); §\C{// print quotient/remainder}§
 \end{cfa}
 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
@@ -2723 +2723 @@
 One way to access the individual components of a tuple variable is with assignment.
 \begin{cfa}
-[ quot, rem ] = qr;                                             §\C{// assign multiple variables}§
+[ quot, rem ] = qr; §\C{// assign multiple variables}§
 \end{cfa}
 
@@ -2746 +2746 @@
 [int, double] * p;
 
-int y = x.0;                                                    §\C{// access int component of x}§
-y = f().1;                                                              §\C{// access int component of f}§
-p->0 = 5;                                                               §\C{// access int component of tuple pointed-to by p}§
-g( x.1, x.0 );                                                  §\C{// rearrange x to pass to g}§
-double z = [ x, f() ].0.1;                              §\C{// access second component of first component of tuple expression}§
+int y = x.0; §\C{// access int component of x}§
+y = f().1; §\C{// access int component of f}§
+p->0 = 5; §\C{// access int component of tuple pointed-to by p}§
+g( x.1, x.0 ); §\C{// rearrange x to pass to g}§
+double z = [ x, f() ].0.1; §\C{// access second component of first component of tuple expression}§
 \end{cfa}
 Tuple-index expressions can occur on any tuple-typed expression, including tuple-returning functions, square-bracketed tuple expressions, and other tuple-index expressions, provided the retrieved component is also a tuple.
@@ -2817 +2817 @@
 double y;
 [int, double] z;
-[y, x] = 3.14;                                                  §\C{// mass assignment}§
+[y, x] = 3.14; §\C{// mass assignment}§
 [x, y] = z;                                                         §\C{// multiple assignment}§
 z = 10;                                                         §\C{// mass assignment}§
-z = [x, y];                                                             §\C{// multiple assignment}§
+z = [x, y]; §\C{// multiple assignment}§
 \end{cfa}
 Let $L_i$ for $i$ in $[0, n)$ represent each component of the flattened left side, $R_i$ represent each component of the flattened right side of a multiple assignment, and $R$ represent the right side of a mass assignment.
@@ -2864 +2864 @@
         double c, d;
         [ void ] f( [ int, int ] );
-        f( [ c, a ] = [ b, d ] = 1.5 );  // assignments in parameter list
+        f( [ c, a ] = [ b, d ] = 1.5 ); §\C{// assignments in parameter list}§
 \end{cfa}
 The tuple expression begins with a mass assignment of ©1.5© into ©[b, d]©, which assigns ©1.5© into ©b©, which is truncated to ©1©, and ©1.5© into ©d©, producing the tuple ©[1, 1.5]© as a result.
@@ -2877 +2877 @@
 \begin{cfa}
 struct S;
-void ?{}(S *);         // (1)
-void ?{}(S *, int);    // (2)
-void ?{}(S * double);  // (3)
-void ?{}(S *, S);      // (4)
-
-[S, S] x = [3, 6.28];  // uses (2), (3), specialized constructors
-[S, S] y;              // uses (1), (1), default constructor
-[S, S] z = x.0;        // uses (4), (4), copy constructor
+void ?{}(S *); §\C{// (1)}§
+void ?{}(S *, int); §\C{// (2)}§
+void ?{}(S * double); §\C{// (3)}§
+void ?{}(S *, S); §\C{// (4)}§
+
+[S, S] x = [3, 6.28]; §\C{// uses (2), (3), specialized constructors}§
+[S, S] y; §\C{// uses (1), (1), default constructor}§
+[S, S] z = x.0; §\C{// uses (4), (4), copy constructor}§
 \end{cfa}
 In this example, ©x© is initialized by the multiple constructor calls ©?{}(&x.0, 3)© and ©?{}(&x.1, 6.28)©, while ©y© is initialized by two default constructor calls ©?{}(&y.0)© and ©?{}(&y.1)©.
@@ -2925 +2925 @@
 A member-access tuple may be used anywhere a tuple can be used, \eg:
 \begin{cfa}
-s.[ y, z, x ] = [ 3, 3.2, 'x' ];                §\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}§
-f( s.[ y, z ] );                                                §\C{// equivalent to f( s.y, s.z )}§
+s.[ y, z, x ] = [ 3, 3.2, 'x' ]; §\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}§
+f( s.[ y, z ] ); §\C{// equivalent to f( s.y, s.z )}§
 \end{cfa}
 Note, the fields appearing in a record-field tuple may be specified in any order;
@@ -2936 +2936 @@
 void f( double, long );
 
-f( x.[ 0, 3 ] );                                                §\C{// f( x.0, x.3 )}§
-x.[ 0, 1 ] = x.[ 1, 0 ];                                §\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}§
+f( x.[ 0, 3 ] ); §\C{// f( x.0, x.3 )}§
+x.[ 0, 1 ] = x.[ 1, 0 ]; §\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}§
 [ long, int, long ] y = x.[ 2, 0, 2 ];
 \end{cfa}
@@ -2954 +2954 @@
 \begin{cfa}
 [ int, float, double ] f();
-[ double, float ] x = f().[ 2, 1 ];             §\C{// f() called once}§
+[ double, float ] x = f().[ 2, 1 ]; §\C{// f() called once}§
 \end{cfa}
 
@@ -2967 +2967 @@
 That is, a cast can be used to select the type of an expression when it is ambiguous, as in the call to an overloaded function.
 \begin{cfa}
-int f();     // (1)
-double f();  // (2)
-
-f();       // ambiguous - (1),(2) both equally viable
-(int)f();  // choose (2)
+int f(); §\C{// (1)}§
+double f(); §\C{// (2)}§
+
+f(); §\C{// ambiguous - (1),(2) both equally viable}§
+(int)f(); §\C{// choose (2)}§
 \end{cfa}
 Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples.
@@ -2979 +2979 @@
 void g();
 
-(void)f();  // valid, ignore results
-(int)g();   // invalid, void cannot be converted to int
+(void)f(); §\C{// valid, ignore results}§
+(int)g(); §\C{// invalid, void cannot be converted to int}§
 
 struct A { int x; };
-(struct A)f();  // invalid, int cannot be converted to A
+(struct A)f(); §\C{// invalid, int cannot be converted to A}§
 \end{cfa}
 In C, line 4 is a valid cast, which calls ©f© and discards its result.
@@ -2999 +2999 @@
         [int, [int, int], int] g();
 
-        ([int, double])f();           // (1) valid
-        ([int, int, int])g();         // (2) valid
-        ([void, [int, int]])g();      // (3) valid
-        ([int, int, int, int])g();    // (4) invalid
-        ([int, [int, int, int]])g();  // (5) invalid
+        ([int, double])f(); §\C{// (1) valid}§
+        ([int, int, int])g(); §\C{// (2) valid}§
+        ([void, [int, int]])g(); §\C{// (3) valid}§
+        ([int, int, int, int])g(); §\C{// (4) invalid}§
+        ([int, [int, int, int]])g(); §\C{// (5) invalid}§
 \end{cfa}
 
@@ -3063 +3063 @@
 void f([int, int], int, int);
 
-f([0, 0], 0, 0);    // no cost
-f(0, 0, 0, 0);      // cost for structuring
-f([0, 0,], [0, 0]); // cost for flattening
-f([0, 0, 0], 0);    // cost for flattening and structuring
+f([0, 0], 0, 0); §\C{// no cost}§
+f(0, 0, 0, 0); §\C{// cost for structuring}§
+f([0, 0,], [0, 0]); §\C{// cost for flattening}§
+f([0, 0, 0], 0); §\C{// cost for flattening and structuring}§
 \end{cfa}
 
@@ -3129 +3129 @@
 [ unsigned int, char ]
 [ double, double, double ]
-[ * int, int * ]                §\C{// mix of CFA and ANSI}§
+[ * int, int * ] §\C{// mix of CFA and ANSI}§
 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
 \end{cfa}
@@ -3136 +3136 @@
 Examples of declarations using tuple types are:
 \begin{cfa}
-[ int, int ] x;                 §\C{// 2 element tuple, each element of type int}§
-* [ char, char ] y;             §\C{// pointer to a 2 element tuple}§
+[ int, int ] x; §\C{// 2 element tuple, each element of type int}§
+* [ char, char ] y; §\C{// pointer to a 2 element tuple}§
 [ [ int, int ] ] z ([ int, int ]);
 \end{cfa}
@@ -3154 +3154 @@
 [ int, int ] w1;
 [ int, int, int ] w2;
-[ void ] f (int, int, int); /* three input parameters of type int */
-[ void ] g ([ int, int, int ]); /* 3 element tuple as input */
+[ void ] f (int, int, int); §\C{// three input parameters of type int}§
+[ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§
 f( [ 1, 2, 3 ] );
 f( w1, 3 );
@@ -3235 +3235 @@
 [ int, int, int, int ] w = [ 1, 2, 3, 4 ];
 int x = 5;
-[ x, w ] = [ w, x ];            §\C{// all four tuple coercions}§
+[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§
 \end{cfa}
 Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
@@ -3323 +3323 @@
 both these examples produce indeterminate results:
 \begin{cfa}
-f( x++, x++ );                          §\C{// C routine call with side effects in arguments}§
-[ v1, v2 ] = [ x++, x++ ];      §\C{// side effects in righthand side of multiple assignment}§
+f( x++, x++ ); §\C{// C routine call with side effects in arguments}§
+[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in righthand side of multiple assignment}§
 \end{cfa}
 
@@ -3346 +3346 @@
 
 
-\section{I/O Library}
-\label{s:IOLibrary}
-\index{input/output library}
-
-The goal of \CFA I/O is to simplify the common cases\index{I/O!common case}, 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 \Indexc{fstream}.
-
-The common case is printing out a sequence of variables separated by whitespace.
+\section{I/O Stream Library}
+\label{s:IOStreamLibrary}
+\index{input/output stream library}
+\index{stream library}
+
+The goal of \CFA input/output (I/O) is to simplify the common cases\index{I/O!common case}, while fully supporting polymorphism and user defined types in a consistent way.
+\CFA I/O combines ideas from C ©printf©, \CC, and Python.
+I/O can be unformatted or formatted.
+Unformatted means \CFA selects the output or input format for values that match with the type of a variable.
+Formatted means additional information is specified to augment how an output or input of value is interpreted.
+\CFA formatting is a cross between C ©printf© and \CC ©cout© manipulators.
+\begin{itemize}
+\item
+©printf© format codes are dense, making them difficult to read and remember.
+\CFA/\CC format manipulators are named, making them easier to read and remember.
+\item
+©printf© separates format codes from associated variables, making it difficult to match codes with variables.
+\CFA/\CC co-locate codes with associated variables, where \CFA has the tighter binding.
+\item
+Format manipulators in \CC have global rather than local effect, except ©setw©.
+Hence, it is common programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects.
+Without this programming style, errors occur when moving prints, as manipulator effects incorrectly flow into the new location.
+(To guarantee no side-effects, manipulator values must be saved and restored across function calls.)
+\end{itemize}
+The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
+
+For unformatted output, the common case is printing a sequence of variables separated by whitespace.
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
@@ -3373 +3391 @@
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-1 2 3
+1® ®2® ®3
 \end{cfa}
 \end{tabular}
 \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]@, @''.
+The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators and newline.
+Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]@, @''.
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
-sout | t1 | t2;                                         §\C{// print tuples}§
+sout | t1 | t2; §\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.
+Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
 Therefore, fewer output expressions require parenthesis.
 \begin{cquote}
@@ -3393 +3411 @@
 &
 \begin{cfa}
-sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2);
+sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
 \end{cfa}
 \\
@@ -3399 +3417 @@
 &
 \begin{cfa}
-cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
 \end{cfa}
 \\
@@ -3408 +3426 @@
 \end{tabular}
 \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.
+Input and output use a uniform operator, ©|©, rather than separate operators, as in ©>>© and ©<<© for \CC.
+There is a weak similarity between the \CFA logical-or operator and the \Index{Shell pipe-operator} for moving data, where data flows in the correct direction for input but the opposite direction for output.
+
+For unformatter input, the common case is reading a sequence of values separated by whitespace, where the type of an input constant must match with the type of the input variable.
+\begin{cquote}
+\begin{lrbox}{\LstBox}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+int x;   double y   char z;
+\end{cfa}
+\end{lrbox}
+\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
+\multicolumn{1}{@{}l@{}}{\usebox\LstBox} \\
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+sin | x | y | z;
+\end{cfa}
+&
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+cin >> x >> y >> z;
+\end{cfa}
+\\
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®1® ®2.5® ®A®
+\end{cfa}
+&
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®1® ®2.5® ®A®
+\end{cfa}
+\end{tabular}
+\end{cquote}
+
 
 
 \subsection{Implicit Separator}
 
-The \Index{implicit separator}\index{I/O!separator} character (space/blank) is a separator not a terminator.
+The \Index{implicit separator}\index{I/O!separator} character (space/blank) is a separator not a terminator for output.
 The rules for implicitly adding the separator are:
 \begin{enumerate}
@@ -3441 +3489 @@
 
 \item
-A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@
+{\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}}
+A seperator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@
+\begin{cfa}[belowskip=0pt]
+sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
+                | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
+\end{cfa}
+\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
+1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x
+\end{cfa}}%
+where \lstinline[basicstyle=\tt]@»@ is a closing citation mark.
+
+\item
+A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@
 %$
 \begin{cfa}[mathescape=off]
@@ -3455 +3515 @@
 
 \item
-{\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}}
-A seperator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@
-\begin{cfa}[belowskip=0pt]
-sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
-                | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
-\end{cfa}
-\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
-1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x
-\end{cfa}}%
-where \lstinline[basicstyle=\tt]@»@ is a closing citation mark.
-
-\item
-A seperator does not appear before or after a C string begining/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
+A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
 \begin{cfa}[belowskip=0pt]
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
@@ -3486 +3534 @@
 
 
-\subsection{Manipulator}
-
-The following \CC-style \Index{manipulator}s and routines control implicit seperation.
+\subsection{Separation Manipulators}
+
+The following \Index{manipulator}s control \Index{implicit output separation}.
+The effect of these manipulators is global for an output stream (except ©sepOn© and ©sepOff©).
 \begin{enumerate}
 \item
-Routines \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
+\Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[mathescape=off,belowskip=0pt]
-sepSet( sout, ", $" );                                          §\C{// set separator from " " to ", \$"}§
+sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§
 sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
 \end{cfa}
@@ -3503 +3552 @@
 %$
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, " " );                                            §\C{// reset separator to " "}§
+sepSet( sout, " " ); §\C{// reset separator to " "}§
 sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
@@ -3511 +3560 @@
 ©sepGet© can be used to store a separator and then restore it:
 \begin{cfa}[belowskip=0pt]
-char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
-strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
-sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
+char store[®sepSize®]; §\C{// sepSize is the maximum separator size}§
+strcpy( store, sepGet( sout ) ); §\C{// copy current separator}§
+sepSet( sout, "_" ); §\C{// change separator to underscore}§
 sout | 1 | 2 | 3;
 \end{cfa}
@@ -3520 +3569 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, store );                                          §\C{// change separator back to original}§
+sepSet( sout, store ); §\C{// change separator back to original}§
 sout | 1 | 2 | 3;
 \end{cfa}
@@ -3528 +3577 @@
 
 \item
-Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepTuple}\index{manipulator!sepTuple@©sepTuple©}/\Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
+\Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepTuple}\index{manipulator!sepTuple@©sepTuple©}/\Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
 The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
-sepSetTuple( sout, " " );                                       §\C{// set tuple separator from ", " to " "}§
+sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§
 sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
 \end{cfa}
@@ -3538 +3587 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSetTuple( sout, ", " );                                      §\C{// reset tuple separator to ", "}§
+sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§
 sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
@@ -3547 +3596 @@
 
 \item
-Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items.
+\Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} toggle printing the separator.
 \begin{cfa}[belowskip=0pt]
-sout | sepDisable | 1 | 2 | 3;                  §\C{// globally turn off implicit separator}§
+sout | sepDisable | 1 | 2 | 3; §\C{// turn off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3555 +3604 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sepEnable | 1 | 2 | 3;           §\C{// globally turn on implicit separator}§
+sout | sepEnable | 1 | 2 | 3; §\C{// turn on implicit separator}§
 \end{cfa}
 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3562 +3611 @@
 
 \item
-Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item.
+\Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} toggle printing the separator with respect to the next printed item, and then return to the global seperator setting.
 \begin{cfa}[belowskip=0pt]
-sout | 1 | sepOff | 2 | 3;                      §\C{// locally turn off implicit separator}§
+sout | 1 | sepOff | 2 | 3; §\C{// turn off implicit separator for the next item}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3570 +3619 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sepDisable | 1 | sepOn | 2 | 3; §\C{// locally turn on implicit separator}§
+sout | sepDisable | 1 | sepOn | 2 | 3; §\C{// turn on implicit separator for the next item}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3577 +3626 @@
 The tuple separator also responses to being turned on and off.
 \begin{cfa}[belowskip=0pt]
-sout | t1 | sepOff | t2;                                §\C{// locally turn on/off implicit separator}§
+sout | t1 | sepOff | t2; §\C{// locally turn on/off implicit separator}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3585 +3634 @@
 use ©sep© to accomplish this functionality.
 \begin{cfa}[belowskip=0pt]
-sout | sepOn | 1 | 2 | 3 | sepOn;       §\C{// sepOn does nothing at start/end of line}§
+sout | sepOn | 1 | 2 | 3 | sepOn; §\C{// sepOn does nothing at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
@@ -3591 +3640 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sout | sep | 1 | 2 | 3 | sep ;          §\C{// use sep to print separator at start/end of line}§
+sout | sep | 1 | 2 | 3 | sep ; §\C{// use sep to print separator at start/end of line}§
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 ® ®1 2 3® ®
+\end{cfa}
+\end{enumerate}
+
+
+\subsection{Newline Manipulators}
+
+The following \Index{manipulator} controls \Index{newline separation} for input and output.
+
+For input:
+\begin{enumerate}[parsep=0pt]
+\item
+\Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, i.e., ignore the remaining characters in the line.
+\item
+\Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} reads the newline character, when reading single characters.
+\item
+\Indexc{nlOff}\index{manipulator!nlOff@©nlOff©} does \emph{not} read the newline character, when reading single characters.
+\end{enumerate}
+For example, in:
+\begin{cfa}
+sin | i | ®nl® | j;
+1 ®2®
+3
+\end{cfa}
+variable ©i© is assigned 1, the 2 is skipped, and variable ©j© is assigned 3.
+
+For output:
+\begin{enumerate}[parsep=0pt]
+\item
+\Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline.
+\begin{cfa}
+sout | nl; §\C{// only print newline}§
+sout | 2; §\C{// implicit newline}§
+sout | 3 | nl | 4 | nl; §\C{// terminating nl merged with implicit newline}§
+sout | 5 | nl | nl; §\C{// again terminating nl merged with implicit newline}§
+sout | 6; §\C{// implicit newline}§
+
+2
+3
+4
+5
+
+6
+\end{cfa}
+Note, a terminating ©nl© is merged (overrides) with the implicit newline at the end of the ©sout© expression, otherwise it is impossible to to print a single newline
+\item
+\Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} implicitly prints a newline at the end of each output expression.
+\item
+\Indexc{nlOff}\index{manipulator!nlOff@©nlOff©} does \emph{not} implicitly print a newline at the end of each output expression.
+\end{enumerate}
+
+
+\subsection{Output Value Manipulators}
+
+The following \Index{manipulator}s control formatting of output values (printing), and only affect the format of the argument.
+\begin{enumerate}
+\item
+\Indexc{bin}( integer )\index{manipulator!bin@©bin©} print value in base 2 preceded by ©0b©/©0B©.
+\begin{cfa}[belowskip=0pt]
+sout | bin( 0 ) | bin( 27HH ) | bin( 27H ) | bin( 27 ) | bin( 27L );
+0b0 0b11011 0b11011 0b11011 0b11011
+sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
+0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b(58 1s)100101
+\end{cfa}
+
+\item
+\Indexc{oct}( integer )\index{manipulator!oct@©oct©} print value in base 8 preceded by ©0©.
+\begin{cfa}[belowskip=0pt]
+sout | oct( 0 ) | oct( 27HH ) | oct( 27H ) | oct( 27 ) | oct( 27L );
+0 033 033 033 033
+sout | oct( -27HH ) | oct( -27H ) | oct( -27 ) | oct( -27L );
+0345 0177745 037777777745 01777777777777777777745
+\end{cfa}
+Note, octal 0 is \emph{not} preceded by ©0© to prevent confusion.
+
+\item
+\Indexc{hex}( integer / floating-point )\index{manipulator!hex@©hex©} print value in base 16 preceded by ©0x©/©0X©.
+\begin{cfa}[belowskip=0pt]
+sout | hex( 0 ) | hex( 27HH ) | hex( 27H ) | hex( 27 ) | hex( 27L );
+0 0x1b 0x1b 0x1b 0x1b
+sout | hex( -27HH ) | hex( -27H ) | hex( -27 ) | hex( -27L );
+0xe5 0xffe5 0xffffffe5 0xffffffffffffffe5
+
+sout | hex( 0.0 ) | hex( 27.5F ) | hex( 27.5 ) | hex( 27.5L );
+0x0.p+0 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
+sout | hex( -27.5F ) | hex( -27.5 ) | hex( -27.5L );
+-0x1.b8p+4 -0x1.b8p+4 -0xd.cp+1
+\end{cfa}
+
+\item
+\Indexc{sci}( floating-point )\index{manipulator!sci@©sci©} print value in scientific notation with exponent.
+Default is 6 digits of precision.
+\begin{cfa}[belowskip=0pt]
+sout | sci( 0.0 ) | sci( 27.5 ) | sci( -27.5 );
+0.000000e+00 2.750000e+01 -2.750000e+01
+\end{cfa}
+
+\item
+\Indexc{upcase}( bin / hex / floating-point )\index{manipulator!upcase@©upcase©} print letters in a value in upper case. Lower case is the default.
+\begin{cfa}[belowskip=0pt]
+sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
+0®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
+\end{cfa}
+
+\item
+\Indexc{nobase}( integer )\index{manipulator!nobase@©nobase©} do not precede ©bin©, ©oct©, ©hex© with ©0b©/©0B©, ©0©, or ©0x©/©0X©. Printing the base is the default.
+\begin{cfa}[belowskip=0pt]
+sout | nobase( bin( 27 ) ) | nobase( oct( 27 ) ) | nobase( hex( 27 ) );
+11011 33 1b
+\end{cfa}
+
+\item
+\Indexc{nodp}( floating-point )\index{manipulator!nodp@©nodp©} do not print a decimal point if there are no fractional digits.
+Printing a decimal point is the default, if there are no fractional digits.
+\begin{cfa}[belowskip=0pt]
+sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
+0.0 ®0® 27.0 ®27® 27.5
+\end{cfa}
+
+\item
+\Indexc{sign}( integer / floating-point )\index{manipulator!sign@©sign©} prefix with plus or minus sign (©+© or ©-©). Only printing the minus sign is the default.
+\begin{cfa}[belowskip=0pt]
+sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
+®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
+\end{cfa}
+
+\item
+\Indexc{wd}©( unsigned char minimum, T val )©\index{manipulator!wd@©wd©}, ©wd( unsigned char minimum, unsigned char precision, T val )©
+For all types, ©minimum© is the minimum number of printed characters.
+If the value is shorter than the minimum, it is padded on the right with spaces.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 4, 34) | wd( 3, 34 ) | wd( 2, 34 );
+sout | wd( 10, 4.) | wd( 9, 4. ) | wd( 8, 4. );
+sout | wd( 4, "ab" ) | wd( 3, "ab" ) | wd( 2, "ab" );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®  ®34 ® ®34 34
+®  ®4.000000 ® ®4.000000 4.000000
+®  ®ab ® ®ab ab
+    ab    ab ab
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the ©minimum©.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 4, 34567 ) | wd( 3, 34567 ) | wd( 2, 34567 );
+sout | wd( 4, 3456. ) | wd( 3, 3456. ) | wd( 2, 3456. );
+sout | wd( 4, "abcde" ) | wd( 3, "abcde" ) | wd( 2,"abcde" );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+3456®7® 345®67® 34®567®
+3456®.® 345®6.® 34®56.®
+abcd®e® abc®de® ab®cde®
+\end{cfa}
+
+For integer types, ©precision© is the minimum number of printed digits.
+If the value is shorter, it is padded on the left with leading zeros.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 4,3, 34 ) | wd( 8,4, 34 ) | wd( 10,10, 34 );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+ ®0®34     ®00®34 ®00000000®34
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the ©precision©.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 4,1, 3456 ) | wd( 8,2, 3456 ) | wd( 10,3, 3456 );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+3456     3456       3456
+\end{cfa}
+If ©precision© is 0, nothing is printed for zero.
+If ©precision© is greater than the minimum, it becomes the minimum.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 4,0, 0 ) | wd( 3,10, 34 );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®    ® ®00000000®34
+\end{cfa}
+For floating-point types, ©precision© is the minimum number of digits after the decimal point.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 6,3, 27.5 ) | wd( 8,1, 27.5 ) | wd( 8,0, 27.5 ) | wd( 3,8, 27.5 );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+27.®500®     27.®5®      28. 27.®50000000®
+\end{cfa}
+For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncared if it exceeds the maximum.
+\begin{cfa}[belowskip=0pt]
+sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+  abcd abcdefgh    abc
+\end{cfa}
+
+\item
+\Indexc{ws( unsigned char minimum, unsigned char significant, floating-point )}\index{manipulator!ws@©ws©}
+For floating-point type, ©minimum© is the same as for manipulator ©wd©, but ©significant© is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
+If a value's significant digits is greater than ©significant©, the last significant digit is rounded up.
+\begin{cfa}[belowskip=0pt]
+sout | ws(6,6, 234.567) | ws(6,5, 234.567) | ws(6,4, 234.567) | ws(6,3, 234.567);
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+234.567 234.5®7®  234.®6®    23®5®
+\end{cfa}
+If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
+\begin{cfa}[belowskip=0pt]
+sout | ws(6,6, 234567.) | ws(6,5, 234567.) | ws(6,4, 234567.) | ws(6,3, 234567.);
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+234567. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
+\end{cfa}
+If ©significant© is greater than ©minimum©, it defines the number of printed characters.
+\begin{cfa}[belowskip=0pt]
+sout | ws(3,6, 234567.) | ws(4,6, 234567.) | ws(5,6, 234567.) | ws(6,6, 234567.);
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+234567. 234567. 234567. 234567.
+\end{cfa}
+
+\item
+\Indexc{left}( field-width )\index{manipulator!left@©left©} left justify within the given field.
+\begin{cfa}[belowskip=0pt]
+sout | left(wd(4, 27)) | left(wd(10, 27.)) | left(wd(10, 27.5)) | left(wd(4,3, 27)) | left(wd(10,3, 27.5));
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+27®  ® 27.000000  27.500000  027  27.500®    ®
+\end{cfa}
+
+\item
+\Indexc{pad0}( field-width )\index{manipulator!pad0@©pad0©} left pad with zeroes (0).
+\begin{cfa}[belowskip=0pt]
+sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
+®00®27  ®0®27 ®00®27.500
 \end{cfa}
 \end{enumerate}
@@ -3655 +3933 @@
 
 
+\subsection{Input Value Manipulators}
+
+The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable.
+For ©_Bool© type, the constants are ©true© and ©false©.
+For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
+\begin{itemize}
+\item
+©1©-©9© prefix introduces a decimal value (©0©-©9©),
+\item
+©0© prefix introduces an octal value (©0©-©7©), and
+\item
+©0x© or ©0X© prefix introduces a hexadecimal value (©0©-©f©) with lower or upper case letters.
+\end{itemize}
+For floating-point types, any number of decimal digits, optionally preceded by a sign (©+© or ©-©), optionally containing a decimal point, and optionally followed by an exponent, ©e© or ©E©, with signed (optional) decimal digits.
+Floating-point values can also be written in hexadecimal format preceded by ©0x© or ©0X© with hexadecimal digits and exponent denoted by ©p© or ©P©.
+
+For the C-string type, the input values are \emph{not} the same as C-string constants, \ie double quotes bracketing arbitrary text with escape sequences.
+Instead, the next sequence of non-whitespace characters are read, and the input sequence is terminated with delimiter ©'\0'©.
+The string variable \emph{must} be large enough to contain the input sequence.
+
+The following \Index{manipulator}s control formatting of input values (reading), and only affect the format of the argument.
+
+\begin{enumerate}
+\item
+\Indexc{skip( const char * pattern )}\index{manipulator!skip@©skip©} / ©skip( unsigned int length )© / ©const char * pattern©
+The argument defines a ©pattern© or ©length©.
+The ©pattern© is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The ©length© is composed of the next $N$ characters, including the newline character.
+If the match successes, the input characters are discarded, and input continues with the next character.
+If the match fails, the input characters are left unread.
+\begin{cfa}[belowskip=0pt]
+char sk[$\,$] = "abc";
+sin | "abc " | skip( sk ) | skip( 5 ); // match input sequence
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®abc   ®
+®abc  ®
+®xx®
+\end{cfa}
+
+\item
+\Indexc{wdi}©( unsigned int maximum, T & val )©\index{manipulator!wdi@©wdi©}
+For all types except ©char©, ©maximum© is the maximum number of characters read for the current operation.
+\begin{cfa}[belowskip=0pt]
+char s[10];   int i;   double d;   
+sin | wdi( 4, s ) | wdi( 3, i ) | wdi( 8, d );  // c == "abcd", i == 123, d == 3.456E+2
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®abcd1233.456E+2®
+\end{cfa}
+Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
+Currently, \CFA cannot distinguish between these two manipulators in the middle of an ©sout©/©sin© expression based on return type.
+
+\item
+\Indexc{ignore( T & val )}\index{manipulator!ignore@©ignore©}
+For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
+\begin{cfa}[belowskip=0pt]
+double d;
+sin | ignore( d );  // d is unchanged
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®  -75.35e-4® 25
+\end{cfa}
+
+\item
+\Indexc{incl( const char * scanset, char * s )}\index{manipulator!incl@©incl©}
+For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{in} the set.
+Matching characters are read into the C string and null terminated.
+\begin{cfa}[belowskip=0pt]
+char s[10];
+sin | incl( "abc", s );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®bca®xyz
+\end{cfa}
+
+\item
+\Indexc{excl( const char * scanset, char * s )}\index{manipulator!excl@©excl©}
+For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{not in} the set.
+Non-matching characters are read into the C string and null terminated.
+\begin{cfa}[belowskip=0pt]
+char s[10];
+sin | excl( "abc", s );
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+®xyz®bca
+\end{cfa}
+\end{enumerate}
+
+
 \section{Types}
 
@@ -4022 +4390 @@
 \begin{itemize}
 \item
-preventing having to determine or write long generic types,
-\item
-ensure secondary variables, related to a primary variable, always have the same type.
+not determining or writing long generic types,
+\item
+ensuring secondary variables, related to a primary variable, always have the same type.
 \end{itemize}
 
@@ -4046 +4414 @@
 There is also the conundrum in type inferencing of when to \emph{\Index{brand}} a type.
 That is, when is the type of the variable more important than the type of its initialization expression.
-For example, if a change is made in an initialization expression, it can cause significant cascading type changes and/or errors.
+For example, if a change is made in an initialization expression, it can cause cascading type changes and/or errors.
 At some point, a variable type needs to remain constant and the expression to be in error when it changes.
 
@@ -4279 +4647 @@
 
 coroutine Fibonacci {
-        int fn;                                                         §\C{// used for communication}§
+        int fn; §\C{// used for communication}§
 };
 void ?{}( Fibonacci * this ) {
@@ -4285 +4653 @@
 }
 void main( Fibonacci * this ) {
-        int fn1, fn2;                                           §\C{// retained between resumes}§
-        this->fn = 0;                                           §\C{// case 0}§
+        int fn1, fn2; §\C{// retained between resumes}§
+        this->fn = 0; §\C{// case 0}§
         fn1 = this->fn;
-        suspend();                                                      §\C{// return to last resume}§
-
-        this->fn = 1;                                           §\C{// case 1}§
+        suspend(); §\C{// return to last resume}§
+
+        this->fn = 1; §\C{// case 1}§
         fn2 = fn1;
         fn1 = this->fn;
-        suspend();                                                      §\C{// return to last resume}§
-
-        for ( ;; ) {                                            §\C{// general case}§
+        suspend(); §\C{// return to last resume}§
+
+        for ( ;; ) { §\C{// general case}§
                 this->fn = fn1 + fn2;
                 fn2 = fn1;
                 fn1 = this->fn;
-                suspend();                                              §\C{// return to last resume}§
+                suspend(); §\C{// return to last resume}§
         } // for
 }
 int next( Fibonacci * this ) {
-        resume( this );                                         §\C{// transfer to last suspend}§
+        resume( this ); §\C{// transfer to last suspend}§
         return this->fn;
 }
@@ -5848 +6216 @@
 In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as:
 \begin{cfa}
-*?§\color{red}\textvisiblespace§*?              §\C{// dereference operator, dereference operator}§
-*§\color{red}\textvisiblespace§?*?              §\C{// dereference, multiplication operator}§
+*?§\color{red}\textvisiblespace§*? §\C{// dereference operator, dereference operator}§
+*§\color{red}\textvisiblespace§?*? §\C{// dereference, multiplication operator}§
 \end{cfa}
 By default, the first interpretation is selected, which does not yield a meaningful parse.
@@ -5901 +6269 @@
 \eg:
 \begin{cfa}
-x;                                                              §\C{// int x}§
-*y;                                                             §\C{// int *y}§
-f( p1, p2 );                                    §\C{// int f( int p1, int p2 );}§
-g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
+x; §\C{// int x}§
+*y; §\C{// int *y}§
+f( p1, p2 ); §\C{// int f( int p1, int p2 );}§
+g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§
 \end{cfa}
 \CFA continues to support K\&R routine definitions:
 \begin{cfa}
-f( a, b, c )                                    §\C{// default int return}§
-        int a, b; char c                        §\C{// K\&R parameter declarations}§
+f( a, b, c ) §\C{// default int return}§
+        int a, b; char c §\C{// K\&R parameter declarations}§
 {
         ...
@@ -5928 +6296 @@
 int rtn( int i );
 int rtn( char c );
-rtn( 'x' );                                             §\C{// programmer expects 2nd rtn to be called}§
+rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§
 \end{cfa}
 \item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
@@ -5950 +6318 @@
 \item[Change:] make string literals ©const©:
 \begin{cfa}
-char * p = "abc";                               §\C{// valid in C, deprecated in \CFA}§
-char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
+char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§
+char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
 \end{cfa}
 The type of a string literal is changed from ©[] char© to ©const [] char©.
@@ -5958 +6326 @@
 \begin{cfa}
 char * p = "abc";
-p[0] = 'w';                                             §\C{// segment fault or change constant literal}§
+p[0] = 'w'; §\C{// segment fault or change constant literal}§
 \end{cfa}
 The same problem occurs when passing a string literal to a routine that changes its argument.
@@ -5970 +6338 @@
 \item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
 \begin{cfa}
-int i;                                                  §\C{// forward definition}§
-int *j = ®&i®;                                  §\C{// forward reference, valid in C, invalid in \CFA}§
-int i = 0;                                              §\C{// definition}§
+int i; §\C{// forward definition}§
+int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§
+int i = 0; §\C{// definition}§
 \end{cfa}
 is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
@@ -5978 +6346 @@
 \begin{cfa}
 struct X { int i; struct X *next; };
-static struct X a;                              §\C{// forward definition}§
+static struct X a; §\C{// forward definition}§
 static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
-static struct X a = { 1, &b };  §\C{// definition}§
+static struct X a = { 1, &b }; §\C{// definition}§
 \end{cfa}
 \item[Rationale:] avoids having different initialization rules for builtin types and user-defined types.
@@ -5995 +6363 @@
 struct Person {
         enum ®Colour® { R, G, B };      §\C[7cm]{// nested type}§
-        struct Face {                           §\C{// nested type}§
-                ®Colour® Eyes, Hair;    §\C{// type defined outside (1 level)}§
+        struct Face { §\C{// nested type}§
+                ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§
         };
-        ®.Colour® shirt;                        §\C{// type defined outside (top level)}§
-        ®Colour® pants;                         §\C{// type defined same level}§
-        Face looks[10];                         §\C{// type defined same level}§
+        ®.Colour® shirt; §\C{// type defined outside (top level)}§
+        ®Colour® pants; §\C{// type defined same level}§
+        Face looks[10]; §\C{// type defined same level}§
 };
-®Colour® c = R;                                 §\C{// type/enum defined same level}§
+®Colour® c = R; §\C{// type/enum defined same level}§
 Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§
-Person®.®Face pretty;                   §\C{// type defined inside}\CRT§
+Person®.®Face pretty; §\C{// type defined inside}\CRT§
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
@@ -6021 +6389 @@
 \item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
 \begin{cfa}
-struct Y;                                               §\C{// struct Y and struct X are at the same scope}§
+struct Y; §\C{// struct Y and struct X are at the same scope}§
 struct X {
         struct Y { /* ... */ } y;
@@ -6036 +6404 @@
 \begin{cfa}
 void foo() {
-        int * b = malloc( sizeof(int) );        §\C{// implicitly convert void * to int *}§
-        char * c = b;                           §\C{// implicitly convert int * to void *, and then void * to char *}§
+        int * b = malloc( sizeof(int) ); §\C{// implicitly convert void * to int *}§
+        char * c = b; §\C{// implicitly convert int * to void *, and then void * to char *}§
 }
 \end{cfa}
@@ -6298 +6666 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-forall( otype T | { int ?<?( T, T ); } )        §\C{// location}§
+forall( otype T | { int ?<?( T, T ); } ) §\C{// location}§
 T * bsearch( T key, const T * arr, size_t dim );§\indexc{bsearch}§
 
-forall( otype T | { int ?<?( T, T ); } )        §\C{// position}§
+forall( otype T | { int ?<?( T, T ); } ) §\C{// position}§
 unsigned int bsearch( T key, const T * arr, size_t dim );
 
@@ -6308 +6676 @@
 
 forall( otype E | { int ?<?( E, E ); } ) {
-        E * bsearch( E key, const E * vals, size_t dim );§\indexc{bsearch}§     §\C{// location}§
+        E * bsearch( E key, const E * vals, size_t dim );§\indexc{bsearch}§ §\C{// location}§
         size_t bsearch( E key, const E * vals, size_t dim );§\C{// position}§
         E * bsearchl( E key, const E * vals, size_t dim );§\indexc{bsearchl}§
@@ -6356 +6724 @@
 void srandom( unsigned int seed );§\indexc{srandom}§
 char random( void );§\indexc{random}§
-char random( char u );                                          §\C{// [0,u)}§
-char random( char l, char u );                          §\C{// [l,u)}§
+char random( char u ); §\C{// [0,u)}§
+char random( char l, char u ); §\C{// [l,u)}§
 int random( void );
-int random( int u );                                            §\C{// [0,u)}§
-int random( int l, int u );                                     §\C{// [l,u)}§
+int random( int u ); §\C{// [0,u)}§
+int random( int l, int u ); §\C{// [l,u)}§
 unsigned int random( void );
-unsigned int random( unsigned int u );          §\C{// [0,u)}§
+unsigned int random( unsigned int u ); §\C{// [0,u)}§
 unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u)}§
 long int random( void );
-long int random( long int u );                          §\C{// [0,u)}§
-long int random( long int l, long int u );      §\C{// [l,u)}§
+long int random( long int u ); §\C{// [0,u)}§
+long int random( long int l, long int u ); §\C{// [l,u)}§
 unsigned long int random( void );
 unsigned long int random( unsigned long int u ); §\C{// [0,u)}§
@@ -6417 +6785 @@
 [ int, long double ] remquo( long double, long double );
 
-float div( float, float, int * );§\indexc{div}§ §\C{// alternative name for remquo}§
+float div( float, float, int * );§\indexc{div}§ §\C{// alternative name for remquo}§
 double div( double, double, int * );
 long double div( long double, long double, int * );
@@ -6573 +6941 @@
 long double atan2( long double, long double );
 
-float atan( float, float );                                     §\C{// alternative name for atan2}§
+float atan( float, float ); §\C{// alternative name for atan2}§
 double atan( double, double );§\indexc{atan}§
 long double atan( long double, long double );
@@ -6764 +7132 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
-        int64_t tv;                                                     §\C{// nanoseconds}§
+        int64_t tv; §\C{// nanoseconds}§
 };
 
@@ -6894 +7262 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
-        uint64_t tv;                                            §\C{// nanoseconds since UNIX epoch}§
+        uint64_t tv; §\C{// nanoseconds since UNIX epoch}§
 };
 
@@ -6965 +7333 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Clock {
-        Duration offset;                                        §\C{// for virtual clock: contains offset from real-time}§
-        int clocktype;                                          §\C{// implementation only -1 (virtual), CLOCK\_REALTIME}§
+        Duration offset; §\C{// for virtual clock: contains offset from real-time}§
+        int clocktype; §\C{// implementation only -1 (virtual), CLOCK\_REALTIME}§
 };
 
@@ -6974 +7342 @@
 void ?{}( Clock & clk, Duration adj );
 
-Duration getResNsec();                                  §\C{// with nanoseconds}§
-Duration getRes();                                              §\C{// without nanoseconds}§
-
-Time getTimeNsec();                                             §\C{// with nanoseconds}§
-Time getTime();                                                 §\C{// without nanoseconds}§
+Duration getResNsec(); §\C{// with nanoseconds}§
+Duration getRes(); §\C{// without nanoseconds}§
+
+Time getTimeNsec(); §\C{// with nanoseconds}§
+Time getTime(); §\C{// without nanoseconds}§
 Time getTime( Clock & clk );
 Time ?()( Clock & clk );
@@ -6994 +7362 @@
 
 \begin{cfa}
-void ?{}( Int * this );                                 §\C{// constructor/destructor}§
+void ?{}( Int * this ); §\C{// constructor/destructor}§
 void ?{}( Int * this, Int init );
 void ?{}( Int * this, zero_t );
@@ -7003 +7371 @@
 void ^?{}( Int * this );
 
-Int ?=?( Int * lhs, Int rhs );                  §\C{// assignment}§
+Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§
 Int ?=?( Int * lhs, long int rhs );
 Int ?=?( Int * lhs, unsigned long int rhs );
@@ -7020 +7388 @@
 unsigned long int narrow( Int val );
 
-int ?==?( Int oper1, Int oper2 );               §\C{// comparison}§
+int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§
 int ?==?( Int oper1, long int oper2 );
 int ?==?( long int oper2, Int oper1 );
@@ -7056 +7424 @@
 int ?>=?( unsigned long int oper1, Int oper2 );
 
-Int +?( Int oper );                                             §\C{// arithmetic}§
+Int +?( Int oper ); §\C{// arithmetic}§
 Int -?( Int oper );
 Int ~?( Int oper );
@@ -7138 +7506 @@
 Int ?>>=?( Int * lhs, mp_bitcnt_t shift );
 
-Int abs( Int oper );                                    §\C{// number functions}§
+Int abs( Int oper ); §\C{// number functions}§
 Int fact( unsigned long int N );
 Int gcd( Int oper1, Int oper2 );
@@ -7249 +7617 @@
 // implementation
 struct Rational {§\indexc{Rational}§
-        long int numerator, denominator;        §\C{// invariant: denominator > 0}§
+        long int numerator, denominator; §\C{// invariant: denominator > 0}§
 }; // Rational
 
-Rational rational();                                    §\C{// constructors}§
+Rational rational(); §\C{// constructors}§
 Rational rational( long int n );
 Rational rational( long int n, long int d );
@@ -7258 +7626 @@
 void ?{}( Rational * r, one_t );
 
-long int numerator( Rational r );               §\C{// numerator/denominator getter/setter}§
+long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§
 long int numerator( Rational r, long int n );
 long int denominator( Rational r );
 long int denominator( Rational r, long int d );
 
-int ?==?( Rational l, Rational r );             §\C{// comparison}§
+int ?==?( Rational l, Rational r ); §\C{// comparison}§
 int ?!=?( Rational l, Rational r );
 int ?<?( Rational l, Rational r );
@@ -7270 +7638 @@
 int ?>=?( Rational l, Rational r );
 
-Rational -?( Rational r );                              §\C{// arithmetic}§
+Rational -?( Rational r ); §\C{// arithmetic}§
 Rational ?+?( Rational l, Rational r );
 Rational ?-?( Rational l, Rational r );
@@ -7276 +7644 @@
 Rational ?/?( Rational l, Rational r );
 
-double widen( Rational r );                             §\C{// conversion}§
+double widen( Rational r ); §\C{// conversion}§
 Rational narrow( double f, long int md );