Changes in doc/user/user.tex [e71b09a:5ecaeca]

File:

• doc/user/user.tex (modified) (151 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 : Tue Jan 30 09:02:41 2024
-%% Update Count     : 6046
+%% Last Modified On : Sun Jan 14 17:27:41 2024
+%% Update Count     : 5764
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -46 +46 @@
 %\input{common}                                                                                 % common CFA document macros
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
-\urlstyle{sf}
 \usepackage{breakurl}
 
@@ -164 +163 @@
 
 \Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
-However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that are difficult to update, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C code-base.
+However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that are difficult to update, and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project.
 In contrast, \CFA has 30 years of hindsight and a clean starting point.
 
@@ -201 +200 @@
 \end{center}
 While \CFA I/O \see{\VRef{s:StreamIOLibrary}} looks similar to \Index*[C++]{\CC{}}, there are important differences, such as automatic spacing between variables and an implicit newline at the end of the expression list, similar to \Index*{Python}~\cite{Python}.
-In general, \CFA programs are 10\% to 30\% shorter than their equivalent C/\CC counterparts.
 
 
@@ -220 +218 @@
 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is the only language of choice.
-The TIOBE index~\cite{TIOBE} for February 2023 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail.
+The TIOBE index~\cite{TIOBE} for February 2021 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail.
 The top 4 rankings over the past 35 years are:
 \begin{center}
@@ -240 +238 @@
 however, it largely extended the C language, and did not address many of C's existing problems.\footnote{%
 Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
-\Index*{Fortran}~\cite{Fortran08}, \Index*{Cobol}~\cite{Cobol14}, and \Index*{Ada}~\cite{Ada16} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
+\Index*{Fortran}~\cite{Fortran08}, \Index*{Cobol}~\cite{Cobol14}, and \Index*{Ada}~\cite{Ada12} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
 \Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
 These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection.
@@ -265 +263 @@
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}.
-However, at that time, there was little interest in extending C, so work did not continue.
+However, at that time, there was little interesting in extending C, so work did not continue.
 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of the legacy code-base, so the \CFA project was restarted in 2015.
 
@@ -274 +272 @@
 \CFA is designed to integrate directly with existing C programs and libraries.
 The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no complex interface or overhead to call existing C routines.
-This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of software features.
+This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
 Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at zero or very low cost.
@@ -322 +320 @@
 However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
 For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
-Whereas, \CFA wraps these routines into one overloaded name ©abs©:
-\begin{cfa}
-unsigned char ®abs®( signed char );                             §\C[3.5in]{// no C equivalent}§
-extern "C" { int ®abs®( int ); }                                §\C{// C abs}§
-unsigned long int ®abs®( long int );                    §\C{// C labs}§
-unsigned long long int ®abs®( long long int );  §\C{// C llabs}§
-float ®abs®( float );                                                   §\C{// C fabsf}§
-double ®abs®( double );                                                 §\C{// C fabs}§
-long double ®abs®( long double );                               §\C{// C fabsl}§
-float _Complex ®abs®( float _Complex );                 §\C{// C cabsf}§
-double _Complex ®abs®( double _Complex );               §\C{// C cabs}§
-long double _Complex ®abs®( long double _Complex ); §\C{// C cabsl}\CRT§
+Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
+\begin{cfa}
+char ®abs®( char );
+extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§
+long int ®abs®( long int );
+long long int ®abs®( long long int );
+float ®abs®( float );
+double ®abs®( double );
+long double ®abs®( long double );
+float _Complex ®abs®( float _Complex );
+double _Complex ®abs®( double _Complex );
+long double _Complex ®abs®( long double _Complex );
 \end{cfa}
 The problem is a \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default).
@@ -341 +339 @@
 
 This example illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
-The name ``©abs©'' evokes the notion of absolute value and many mathematical types provide the notion of absolute value.
-Hence, knowing the name ©abs© is sufficient to apply it to any applicable type.
+The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
+Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
 The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
 
 
 \section{\CFA Compilation}
-
-\CFA is a \newterm{transpiler}, meaning it reads in a programming language (\CFA) as input and generates another programming language (C) as output, whereas a \newterm{compiler} reads in a programming language and generates assembler/machine code.
-Hence, \CFA is like the C preprocessor modifying a program and sending it on to another step for further transformation.
-The order of transformation is C preprocessor, \CFA, and finally GNU C compiler, which also has a number of transformation steps, such as assembler and linker.
 
 The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
@@ -450 +444 @@
 which conditionally includes the correct header file, if the program is compiled using \Indexc{gcc} or \Indexc{cfa}.
 
-The \CFA \Index{transpiler} has multiple internal steps.
-The following flags control how the \CFA transpiler works, the stages run, and printing within a stage.
+The \CFA translator has multiple steps.
+The following flags control how the translator works, the stages run, and printing within a stage.
 The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers.
-Each option must be escaped with \Indexc{-XCFA}\index{transpiler option!-XCFA@{©-XCFA©}} to direct it to the \CFA compilation step, similar to the ©-Xlinker© flag for the linker, \eg:
+Each option must be escaped with \Indexc{-XCFA}\index{translator option!-XCFA@{©-XCFA©}} to direct it to the compiler step, similar to the ©-Xlinker© flag for the linker, \eg:
 \begin{lstlisting}[language=sh]
 cfa §test§.cfa -CFA -XCFA -p # print translated code without printing the standard prelude
@@ -464 +458 @@
 \begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt]
 \item
-\Indexc{-c}\index{transpiler option!-c@{©-c©}}, \Indexc{--colors}\index{transpiler option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto}
-\item
-\Indexc{-g}\index{transpiler option!-g@{©-g©}}, \Indexc{--gdb}\index{transpiler option!--gdb@{©--gdb©}} \, wait for gdb to attach
-\item
-\Indexc{-h}\index{transpiler option!-h@{©-h©}}, \Indexc{--help}\index{transpiler option!--help@{©--help©}} \, print transpiler help message
-\item
-\Indexc{-i}\index{transpiler option!-i@{©-i©}}, \Indexc{--invariant}\index{transpiler option!--invariant@{©--invariant©}} \, invariant checking during AST passes
-\item
-\Indexc{-l}\index{transpiler option!-l@{©-l©}}, \Indexc{--libcfa}\index{transpiler option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c©
-\item
-\Indexc{-L}\index{transpiler option!-L@{©-L©}}, \Indexc{--linemarks}\index{transpiler option!--linemarks@{©--linemarks©}} \, generate line marks
-\item
-\Indexc{-m}\index{transpiler option!-m@{©-m©}}, \Indexc{--no-main}\index{transpiler option!--no-main@{©--no-main©}} \, do not replace main
-\item
-\Indexc{-N}\index{transpiler option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{transpiler option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks
-\item
-\Indexc{-n}\index{transpiler option!-n@{©-n©}}, \Indexc{--no-prelude}\index{transpiler option!--no-prelude@{©--no-prelude©}} \, do not read prelude
-\item
-\Indexc{-p}\index{transpiler option!-p@{©-p©}}, \Indexc{--prototypes}\index{transpiler option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed
-\item
-\Indexc{-d}\index{transpiler option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{transpiler option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output
-\item
-\Indexc{-P}\index{transpiler option!-P@{©-P©}}, \Indexc{--print}\index{transpiler option!--print@{©--print©}} \, one of:
+\Indexc{-c}\index{translator option!-c@{©-c©}}, \Indexc{--colors}\index{translator option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto}
+\item
+\Indexc{-g}\index{translator option!-g@{©-g©}}, \Indexc{--gdb}\index{translator option!--gdb@{©--gdb©}} \, wait for gdb to attach
+\item
+\Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print translator help message
+\item
+\Indexc{-i}\index{translator option!-i@{©-i©}}, \Indexc{--invariant}\index{translator option!--invariant@{©--invariant©}} \, invariant checking during AST passes
+\item
+\Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c©
+\item
+\Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks
+\item
+\Indexc{-m}\index{translator option!-m@{©-m©}}, \Indexc{--no-main}\index{translator option!--no-main@{©--no-main©}} \, do not replace main
+\item
+\Indexc{-N}\index{translator option!-N@{©-N©}}, \Indexc{--no-linemarks}\index{translator option!--no-linemarks@{©--no-linemarks©}} \, do not generate line marks
+\item
+\Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude
+\item
+\Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed
+\item
+\Indexc{-d}\index{translator option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{translator option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output
+\item
+\Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of:
 \begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
 \item
-\Indexc{ascodegen}\index{transpiler option!-P@{©-P©}!©ascodegen©}\index{transpiler option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST
-\item
-\Indexc{asterr}\index{transpiler option!-P@{©-P©}!©asterr©}\index{transpiler option!--print@{©-print©}!©asterr©} \, print AST on error
-\item
-\Indexc{declstats}\index{transpiler option!-P@{©-P©}!©declstats©}\index{transpiler option!--print@{©-print©}!©declstats©} \, print code property statistics
-\item
-\Indexc{parse}\index{transpiler option!-P@{©-P©}!©parse©}\index{transpiler option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information
-\item
-\Indexc{pretty}\index{transpiler option!-P@{©-P©}!©pretty©}\index{transpiler option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag
-\item
-\Indexc{rproto}\index{transpiler option!-P@{©-P©}!©rproto©}\index{transpiler option!--print@{©-print©}!©rproto©} \, resolver-proto instance
-\item
-\Indexc{rsteps}\index{transpiler option!-P@{©-P©}!©rsteps©}\index{transpiler option!--print@{©-print©}!©rsteps©} \, print resolver steps
-\item
-\Indexc{ast}\index{transpiler option!-P@{©-P©}!©ast©}\index{transpiler option!--print@{©-print©}!©ast©} \, print AST after parsing
-\item
-\Indexc{excpdecl}\index{transpiler option!-P@{©-P©}!©excpdecl©}\index{transpiler option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls
-\item
-\Indexc{symevt}\index{transpiler option!-P@{©-P©}!©symevt©}\index{transpiler option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
-\item
-\Indexc{expralt}\index{transpiler option!-P@{©-P©}!©expralt©}\index{transpiler option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
-\item
-\Indexc{valdecl}\index{transpiler option!-P@{©-P©}!©valdecl©}\index{transpiler option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass
-\item
-\Indexc{bresolver}\index{transpiler option!-P@{©-P©}!©bresolver©}\index{transpiler option!--print@{©-print©}!©bresolver©} \, print AST before resolver step
-\item
-\Indexc{expranly}\index{transpiler option!-P@{©-P©}!©expranly©}\index{transpiler option!--print@{©-print©}!©expranly©} \, print AST after expression analysis
-\item
-\Indexc{ctordtor}\index{transpiler option!-P@{©-P©}!©ctordtor©}\index{transpiler option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced
-\item
-\Indexc{tuple}\index{transpiler option!-P@{©-P©}!©tuple©}\index{transpiler option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion
-\item
-\Indexc{instgen}\index{transpiler option!-P@{©-P©}!©instgen©}\index{transpiler option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics
-\item
-\Indexc{bbox}\index{transpiler option!-P@{©-P©}!©bbox©}\index{transpiler option!--print@{©-print©}!©bbox©} \, print AST before box pass
-\item
-\Indexc{bcodegen}\index{transpiler option!-P@{©-P©}!©bcodegen©}\index{transpiler option!--print@{©-print©}!©bcodegen©} \, print AST before code generation
+\Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, print AST as codegen rather than AST
+\item
+\Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, print AST on error
+\item
+\Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, print code property statistics
+\item
+\Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, print yacc (parsing) debug information
+\item
+\Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag
+\item
+\Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance
+\item
+\Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, print resolver steps
+\item
+\Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, print AST after parsing
+\item
+\Indexc{excpdecl}\index{translator option!-P@{©-P©}!©excpdecl©}\index{translator option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls
+\item
+\Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
+\item
+\Indexc{expralt}\index{translator option!-P@{©-P©}!©expralt©}\index{translator option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
+\item
+\Indexc{valdecl}\index{translator option!-P@{©-P©}!©valdecl©}\index{translator option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass
+\item
+\Indexc{bresolver}\index{translator option!-P@{©-P©}!©bresolver©}\index{translator option!--print@{©-print©}!©bresolver©} \, print AST before resolver step
+\item
+\Indexc{expranly}\index{translator option!-P@{©-P©}!©expranly©}\index{translator option!--print@{©-print©}!©expranly©} \, print AST after expression analysis
+\item
+\Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced
+\item
+\Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, print AST after tuple expansion
+\item
+\Indexc{instgen}\index{translator option!-P@{©-P©}!©instgen©}\index{translator option!--print@{©-print©}!©instgen©} \, print AST after instantiate generics
+\item
+\Indexc{bbox}\index{translator option!-P@{©-P©}!©bbox©}\index{translator option!--print@{©-print©}!©bbox©} \, print AST before box pass
+\item
+\Indexc{bcodegen}\index{translator option!-P@{©-P©}!©bcodegen©}\index{translator option!--print@{©-print©}!©bcodegen©} \, print AST before code generation
 \end{description}
 \item
 \Indexc{--prelude-dir} <directory> \, prelude directory for debug/nodebug
 \item
-\Indexc{-S}\index{transpiler option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{transpiler option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none©
-\item
-\Indexc{-t}\index{transpiler option!-t@{©-t©}}, \Indexc{--tree}\index{transpiler option!--tree@{©--tree©}} build in tree
+\Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none©
+\item
+\Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree
 \end{description}
 
@@ -546 +540 @@
 \end{cfa}
 Existing C programs with keyword clashes can be converted by prefixing the keyword identifiers with double backquotes, and eventually the identifier name can be changed to a non-keyword name.
-\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files \see{\VRef{s:StandardHeaders}} can be handled using preprocessor \newterm{interposition}: ©#include_next© and command-line ©-I filename©.
-Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is largely a seamless programming-experience.
+\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files \see{\VRef{s:StandardHeaders}} can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
+Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
 
 \begin{figure}
@@ -597 +591 @@
 the type suffixes ©U©, ©L©, \etc may start with an underscore ©1_U©, ©1_ll© or ©1.0E10_f©.
 \end{enumerate}
-It is significantly easier to read and enter long constants when they are broken up into smaller groupings (most cultures use comma and/or period among digits for the same purpose).
+It is significantly easier to read and enter long constants when they are broken up into smaller groupings (many cultures use comma and/or period among digits for the same purpose).
 This extension is backwards compatible, matches with the use of underscore in variable names, and appears in \Index*{Ada} and \Index*{Java} 8.
 \CC uses the single quote (©'©) as a separator, restricted within a sequence of digits, \eg ©0xaa©©'©©ff©, ©3.141©©'©©592E1©©'©©1©.
-However, the drawback of the \CC approach is difficults parsing for IDEs between character and numeric constants, as quotes are no longer balanced (©'x'© and ©3.14©©'©©159©).
 
 
 \section{Exponentiation Operator}
 
-C, \CC, and Java (and other programming languages) have \emph{no} exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation.
+C, \CC, and Java (and other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation.
 \CFA extends the basic operators with the exponentiation operator ©?©\R{©\\©}©?©\index{?\\?@©?@\@?©} and ©?©\R{©\\©}©=?©\index{?\\=?@©@\@=?©}, as in, ©x ©\R{©\\©}© y© and ©x ©\R{©\\©}©= y©, which means $x^y$ and $x \leftarrow x^y$.
 The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©(w * (((int)x) \ ((int)y))) * z©.
 
 There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
-Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ or shifting if the exponent is 2).
+Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ multiplies or shifting if the exponent is 2).
 Overflow for a large exponent or negative exponent returns zero.
 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
@@ -627 +620 @@
 T ?®\®?( T ep, unsigned long int y );
 \end{cfa}
-A user type ©T© must define one (©1©), and multiplication (©*©) \see{\VRef{s:Operator}}.
+A user type ©T© must define multiplication, one (©1©), and ©*©.
 
 
@@ -638 +631 @@
 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
 
-The \Indexc{if} and \Indexc{while} expressions are extended with declarations, similar to the \Indexc{for} declaration expression.\footnote{
+The \Indexc{if}/\Indexc{while} expression allows declarations, similar to \Indexc{for} declaration expression.\footnote{
 Declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.}
 \begin{cfa}
@@ -660 +653 @@
 \label{s:caseClause}
 
-C restricts the \Indexc{case} clause in a \Indexc{switch} statement to a single value.
+C restricts a \Indexc{case} clause in \Indexc{switch} statement to a single value.
 For multiple ©case© clauses prefixing a statement within the ©switch© statement, it is necessary to have multiple ©case© clauses rather than multiple values.
 Requiring a ©case© clause for each value is not in the spirit of brevity normally associated with C.
@@ -695 +688 @@
 \end{tabular}
 \end{cquote}
-In addition, subranges are allowed to specify a contiguous set of case values.
+In addition, subranges are allowed to specify case values.
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{\hspace{2em}}l@{}}
@@ -808 +801 @@
 \end{cfa}
 This situation is better handled by a list of case values \see{\VRef{s:caseClause}}.
-
-While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive for many programmers and is different from most programming languages with a ©switch© statement.
-Hence, default fall-through semantics results in programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
+While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from most programming languages with a ©switch© statement.
+Hence, default fall-through semantics results in a many programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
 
 \item
@@ -827 +819 @@
 The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
 There are few arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
+
 This C idiom is known as ``\Index*{Duff's device}''~\cite{Duff83}, from this example:
 \begin{cfa}
@@ -1003 +996 @@
 with the current \Indexc{switch}/\Indexc{choose} statement.
 
-
-\subsection{Loop Control}
-
-Looping a fixed number of times, possibly with a loop index, occurs frequently.
-\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}.
-
-The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control are extended to allow an empty conditional, which implies a comparison value of ©1© (true).
-\begin{cfa}
-while ( ®/* empty */®  )                                §\C{// while ( true )}§
-for ( ®/* empty */®  )                                  §\C{// for ( ; true; )}§
-do ... while ( ®/* empty */®  )                 §\C{// do ... while ( true )}§
-\end{cfa}
-
 \begin{figure}
 \begin{tabular}{@{}l@{\hspace{50pt}}|l@{}}
@@ -1023 +1003 @@
 while () { sout | "empty"; break; }
 do { sout | "empty"; break; } while ();
-for () { sout | "empty"; break; }                                                       §\C{sout | nl | nlOff;}§
+for () { sout | "empty"; break; }                                                       §\C[3in]{sout | nl | nlOff;}§
 
 for ( 0 ) { sout | "A"; } sout | "zero";                                        §\C{sout | nl;}§
@@ -1065 +1045 @@
 for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
 for ( i; 5 : j; @ -~ -5 ~ 2 : k; 1.5 ~ @ ) { sout | i | j | k; } §\C{sout | nl;}§
-for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}§
+for ( i; 5 : k; 1.5 ~ @ : j; @ -~ -5 ~ 2 ) { sout | i | j | k; } §\C{sout | nl;}\CRT§
 \end{cfa}
 &
@@ -1128 +1108 @@
 % for ( T i ; 3~9 ) => for ( T i = 3 ; i < 9; i += 1 ) // using 1
 
-The ©for© control is extended with 4 new loop-control operators, which are not overloadable:
+
+\subsection{Loop Control}
+
+Looping a fixed number of times, possibly with a loop index, occurs frequently.
+\CFA condenses simply looping to facilitate coding speed and safety~\see{examples in \VRef[Figure]{f:LoopControlExamples}}.
+
+The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control allow an empty conditional, which implies a comparison value of ©1© (true).
+\begin{cfa}
+while ( ®/* empty */®  )                                §\C{// while ( true )}§
+for ( ®/* empty */®  )                                  §\C{// for ( ; true; )}§
+do ... while ( ®/* empty */®  )                 §\C{// do ... while ( true )}§
+\end{cfa}
+
+The ©for© control has 4 new loop-control operators that are not overloadable:
 \begin{description}[itemsep=0pt,parsep=0pt]
 \item
@@ -1202 +1195 @@
 Similarly, the high value cannot be elided is an anonymous loop index (©1 ~ @©), as there is no index to stop the loop.
 \item
-©:© means add another index.
+©:© means low another index.
 \begin{cfa}
 for ( i; 5 ®:® j; 2 ~ 12 ~ 3 )                  §\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}§
@@ -1219 +1212 @@
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 
-C \Indexc{continue} and \Indexc{break} statements are restricted to one level of nesting for a particular control structure.
+C \Indexc{continue} and \Indexc{break} statements, for altering control flow, are restricted to one level of nesting for a particular control structure.
 This restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©break©!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}, as in Java.
@@ -1309 +1302 @@
 Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure.
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
-Finally, using an explicit target for the transfer, instead of an implicit target, allows new constructs to be added or removed without affecting existing constructs.
+Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
 Otherwise, the implicit targets of the current ©continue© and ©break©, \ie the closest enclosing loop or ©switch©, change as certain constructs are added or removed.
 
@@ -1380 +1373 @@
 \begin{cfa}
 Person p
-®p.®name ...;  ®p.®address ...;  ®p.®sex ...; §\C{// access containing fields}§
+®p.®name; ®p.®address; ®p.®sex;                 §\C{// access containing fields}§
 \end{cfa}
 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
 \begin{cfa}
 struct Ticket { ... } t;
-®p.name®.first ...;  ®p.address®.street ...; §\C{// access nested fields}§
-®t.®departure ...;  ®t.®cost ...;               §\C{// access multiple aggregate}§
+®p.name®.first; ®p.address®.street;             §\C{// access nested fields}§
+®t.®departure; ®t.®cost;                                §\C{// access multiple aggregate}§
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
@@ -1565 +1558 @@
 
 
-\subsection{Non-local Exception}
+\section{Non-local Exception}
 
 \begin{cfa}
@@ -2354 +2347 @@
 \subsection{Implicit String Conversions}
 
-The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including different signness and sizes, implicitly convert to type ©string©.
-\VRef[Figure]{f:ImplicitConversionsString} shows examples of implicit conversions between C strings, integral, floating-point and complex types to ©string©.
-A conversions can be explicitly specified:
-\begin{cfa}
-s = string( "abc" );                            §\C{// converts char * to string}§
-s = string( 5 );                                        §\C{// converts int to string}§
-s = string( 5.5 );                                      §\C{// converts double to string}§
-\end{cfa}
-All conversions from ©string© to ©char *©, attempt to be safe:
-either by requiring the maximum length of the ©char *© storage (©strncpy©) or allocating the ©char *© storage for the string characters (ownership), meaning the programmer must free the storage.
-As well, a string is always null terminates, implying a minimum size of 1 character.
-\begin{cquote}
-\begin{tabular}{@{}l@{\hspace{1.75in}}|@{\hspace{15pt}}l@{}}
-\begin{cfa}
-string s = "abcde";
-char cs[3];
-strncpy( cs, s, sizeof(cs) );           §\C{sout | cs;}§
-char * cp = s;                                          §\C{sout | cp;}§
-delete( cp );
-cp = s + ' ' + s;                                       §\C{sout | cp;}§
-delete( cp );
-\end{cfa}
-&
-\begin{cfa}
-
-
-ab
-abcde
-
-abcde abcde
-
-\end{cfa}
-\end{tabular}
-\end{cquote}
+The types ©char©, ©char *©, ©int©, ©double©, ©_Complex©, including signness and different sizes, implicitly convert to type ©string©.
+\VRef[Figure]{f:ImplicitStringConversions} shows examples of implicit conversion between C strings, integral, floating-point and complex types to ©string©
+The implicit conversions can be specified explicitly, as in:
+\begin{cfa}
+s = string( "abc" );            // converts char * to string
+s = string( 5 );                        // converts int to string
+s = string( 5.5 );                      // converts double to string
+\end{cfa}
+Conversions from ©string© to ©char *© are supported but with restrictions.
+Explicit As well, when a string is converted to a ©char *©, the storage for the ©char *© is created by the conversion operation, which must be subsequently deleted:
+\begin{cfa}
+string x = "abc";
+char *p = x;                            // convert from string to char *
+...
+delete p;                                       // free storage created for p
+\end{cfa}
 
 \begin{figure}
@@ -2395 +2370 @@
         string s;
         // conversion of char and char * to string
-        s = 'x';                                                §\C{sout | s;}§
-        s = "abc";                                              §\C{sout | s;}§
+        s = 'x';                                                §\CD{sout | s;}§
+        s = "abc";                                              §\CD{sout | s;}§
         char cs[5] = "abc";
-        s = cs;                                                 §\C{sout | s;}§
+        s = cs;                                                 §\CD{sout | s;}§
         // conversion of integral, floating-point, and complex to string
-        s = 45hh;                                               §\C{sout | s;}§
-        s = 45h;                                                §\C{sout | s;}§
-        s = -(ssize_t)MAX - 1;                  §\C{sout | s;}§
-        s = (size_t)MAX;                                §\C{sout | s;}§
-        s = 5.5;                                                §\C{sout | s;}§
-        s = 5.5L;                                               §\C{sout | s;}§
-        s = 5.5+3.4i;                                   §\C{sout | s;}§
-        s = 5.5L+3.4Li;                                 §\C{sout | s;}§
+        s = 45hh;                                               §\CD{sout | s;}§
+        s = 45h;                                                §\CD{sout | s;}§
+        s = -(ssize_t)MAX - 1;                  §\CD{sout | s;}§
+        s = (size_t)MAX;                                §\CD{sout | s;}§
+        s = 5.5;                                                §\CD{sout | s;}§
+        s = 5.5L;                                               §\CD{sout | s;}§
+        s = 5.5+3.4i;                                   §\CD{sout | s;}§
+        s = 5.5L+3.4Li;                                 §\CD{sout | s;}§
+        // safe conversion from string to char *
+        strncpy( cs, s, sizeof(cs) );   §\CD{sout | cs;}§
+        char * cp = s;                                  §\CD{sout | cp; // ownership}§
+        delete( cp );
+        cp = s + ' ' + s;                               §\CD{sout | cp; // ownership}§
+        delete( cp );
 \end{cfa}
 &
@@ -2427 +2408 @@
 5.5+3.4i
 5.5+3.4i
+
+5.5+
+5.5+3.4i
+
+5.5+3.4i 5.5+3.4i
+
 \end{cfa}
 \end{tabular}
-\caption{Implicit Conversions to String}
-\label{f:ImplicitConversionsString}
+\caption{Implicit String Conversions}
+\label{f:ImplicitStringConversions}
 \end{figure}
 
 
-\subsection{Size (length)}
-
-The ©size© operation returns the length of a string.
-\begin{cfa}
-i = size( "" );                                         §\C{// i is assigned 0}§
-i = size( "abc" );                                      §\C{// i is assigned 3}§
-i = size( peter );                                      §\C{// i is assigned 5}§
-\end{cfa}
-
-
 \subsection{Comparison Operators}
 
-The binary \Index{relational operator}s, ©<©, ©<=©, ©>©, ©>=©, and \Index{equality operator}s, ©==©, ©!=©, compare strings using lexicographical ordering, where longer strings are greater than shorter strings.
+The binary relational and equality operators ©<©, ©<=©, ©>©, ©>=©, ©==©, ©!=© compare ©string© using lexicographical ordering, where longer strings are greater than shorter strings.
 
 
 \subsection{Concatenation}
 
-The binary operators \Indexc{+} and \Indexc{+=} concatenate two strings, creating the sum of the strings.
-\begin{cfa}
-s = peter + ' ' + digit;                        §\C{// s is assigned "PETER 0123456789"}§
-s += peter;                                                     §\C{// s is assigned "PETER 0123456789PETER"}§
-\end{cfa}
+The binary operator ©+© concatenates two strings.
+\begin{cfa}
+s = peter + digit;                                      §\C{// s is assigned "PETER0123456789"}§
+s += peter;                                                     §\C{// s is assigned "PETER0123456789PETER"}§
+\end{cfa}
+There is also an assignment form ©+=©.
 
 
 \subsection{Repetition}
 
-The binary operators \Indexc{*} and \Indexc{*=} repeat a string $N$ times.
-If $N = 0$, a zero length string, ©""© is returned.
-\begin{cfa}
-s = 'x' * 3;                            §\C{// s is assigned "PETER PETER PETER "}§
-s = (peter + ' ') * 3;                          §\C{// s is assigned "PETER PETER PETER "}§
+The binary operator \Indexc{*} returns a string that is the string repeated ©n© times.
+If ©n = 0©, a zero length string, ©""© is returned.
+\begin{cfa}
+s = (peter + ' ') * 3;                          §\C{// s is assigned "PETER PETER PETER"}§
+\end{cfa}
+There is also an assignment form ©*=©.
+
+
+\subsection{Length}
+
+The ©length© operation
+\begin{cfa}
+int length()
+\end{cfa}
+returns the length of a string variable.
+\begin{cfa}
+i = peter.length();                     §\C{// i is assigned the value 5}§
 \end{cfa}
 
 
 \subsection{Substring}
-The substring operation returns a subset of the string starting at a position in the string and traversing a length.
-\begin{cfa}
-s = peter( 2, 3 );                                      §\C{// s is assigned "ETE"}§
-s = peter( 4, -3 );                                     §\C{// s is assigned "ETE", length is opposite direction}§
-s = peter( 2, 8 );                                      §\C{// s is assigned "ETER", length is clipped to 4}§
-s = peter( 0, -1 );                                     §\C{// s is assigned "", beyond string so clipped to null}§
-s = peter(-1, -1 );                                     §\C{// s is assigned "R", start and length are negative}§
-\end{cfa}
+The substring operation:
+\begin{cfa}
+string operator () (int start, int lnth);
+\end{cfa}
+performs a substring operation that returns the string starting at a specified position (©start©) in the current string, and having the specified length (©lnth©).
 A negative starting position is a specification from the right end of the string.
 A negative length means that characters are selected in the opposite (right to left) direction from the starting position.
 If the substring request extends beyond the beginning or end of the string, it is clipped (shortened) to the bounds of the string.
 If the substring request is completely outside of the original string, a null string located at the end of the original string is returned.
+\begin{cfa}
+s = peter( 2, 3 );                      §\C{// s is assigned "ETE"}§
+s = peter( 4, -3 );                     §\C{// s is assigned "ETE", length is opposite direction}§
+s = peter( 2, 8 );                      §\C{// s is assigned "ETER", length is clipped to 4}§
+s = peter( 0, -1 );                     §\C{// s is assigned "", beyond string so clipped to null}§
+s = peter(-1, -1 );                     §\C{// s is assigned "R", start and length are negative}§
+\end{cfa}
 The substring operation can also appear on the left hand side of the assignment operator.
 The substring is replaced by the value on the right hand side of the assignment.
 The length of the right-hand-side value may be shorter, the same length, or longer than the length of the substring that is selected on the left hand side of the assignment.
-\begin{cfa}
-digit( 3, 3 ) = "";                             §\C{// digit is assigned "0156789"}§
-digit( 4, 3 ) = "xyz";                          §\C{// digit is assigned "015xyz9"}§
-digit( 7, 0 ) = "***";                          §\C{// digit is assigned "015xyz***9"}§
-digit(-4, 3 ) = "$$$";                          §\C{// digit is assigned "015xyz\$\$\$9"}§
+\begin{cfa}[mathescape=false]
+digit( 3, 3 ) = "";             §\C{// digit is assigned "0156789"}§
+digit( 4, 3 ) = "xyz";          §\C{// digit is assigned "015xyz9"}§
+digit( 7, 0 ) = "***";          §\C{// digit is assigned "015xyz***9"}§
+digit(-4, 3 ) = "$$$";          §\C{// digit is assigned "015xyz\$\$\$9"}§
 \end{cfa}
 A substring is treated as a pointer into the base (substringed) string rather than creating a copy of the subtext.
@@ -2507 +2501 @@
 // e is a substring result passed by value
 void test(string &x, string &a, string &b, string &c, string &d, string e) {
-                                                                        §\C{//   x                                a               b               c               d               e}§
-        a( 1, 2 ) = "aaa";                              §\C{// aaaxxxxxxxxxxx   aaax    axx             xxxxx   xxxxx   xxxxx}§
-        b( 2, 12 ) = "bbb";                             §\C{// aaabbbxxxxxxxxx  aaab    abbb    bbxxx   xxxxx   xxxxx}§
-        c( 4, 5 ) = "ccc";                              §\C{// aaabbbxcccxxxxxx aaab    abbb    bbxccc  ccxxx   xxxxx}§
-        c = "yyy";                                              §\C{// aaabyyyxxxxxx    aaab    abyy    yyy             xxxxx   xxxxx}§
-        d( 1, 3 ) = "ddd";                              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   xxxxx}§
-        e( 1, 3 ) = "eee";                              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   eeexx}§
-        x = e;                                                  §\C{// eeexx                    eeex    exx             x                               eeexx}§
+                                                        §\C{//   x                                a               b               c               d               e}§
+        a( 1, 2 ) = "aaa";              §\C{// aaaxxxxxxxxxxx   aaax    axx             xxxxx   xxxxx   xxxxx}§
+        b( 2, 12 ) = "bbb";             §\C{// aaabbbxxxxxxxxx  aaab    abbb    bbxxx   xxxxx   xxxxx}§
+        c( 4, 5 ) = "ccc";              §\C{// aaabbbxcccxxxxxx aaab    abbb    bbxccc  ccxxx   xxxxx}§
+        c = "yyy";                              §\C{// aaabyyyxxxxxx    aaab    abyy    yyy             xxxxx   xxxxx}§
+        d( 1, 3 ) = "ddd";              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   xxxxx}§
+        e( 1, 3 ) = "eee";              §\C{// aaabyyyxdddxx    aaab    abyy    yyy             dddxx   eeexx}§
+        x = e;                                  §\C{// eeexx                    eeex    exx             x                               eeexx}§
 }
 \end{cfa}
@@ -2524 +2518 @@
 For example:
 \begin{cfa}
-s = peter( 2 );                                         §\C{// s is assigned "ETER"}§
-peter( 2 ) = "IPER";                            §\C{// peter is assigned "PIPER"}§
+s = peter( 2 );                         §\C{// s is assigned "ETER"}§
+peter( 2 ) = "IPER";            §\C{// peter is assigned "PIPER"}§
 \end{cfa}
 It is also possible to substring using a string as the index for selecting the substring portion of the string.
@@ -2533 +2527 @@
 For example:
 \begin{cfa}[mathescape=false]
-digit( "xyz$$$" ) = "678";                      §\C{// digit is assigned "0156789"}§
-digit( "234") = "***";                          §\C{// digit is assigned "0156789***"}§
-\end{cfa}
+digit( "xyz$$$" ) = "678";      §\C{// digit is assigned "0156789"}§
+digit( "234") = "***";          §\C{// digit is assigned "0156789***"}§
+\end{cfa}
+%$
 
 
@@ -2575 +2570 @@
 A negative starting position is a specification from the right end of the string.
 \begin{cfa}
-i = peter.include( digitmask );         §\C{// i is assigned 1}§
-i = peter.include( alphamask );         §\C{// i is assigned 6}§
+i = peter.include( digitmask ); §\C{// i is assigned 1}§
+i = peter.include( alphamask ); §\C{// i is assigned 6}§
 \end{cfa}
 
@@ -2627 +2622 @@
 \begin{cfa}
 // remove leading blanks
-s = string( "   ABC" ).trim( " " );     §\C{// s is assigned "ABC",}§
+s = string( "   ABC" ).trim( " " );                     §\C{// s is assigned "ABC",}§
 // remove trailing blanks
-s = string( "ABC   " ).trim( " ", last ); §\C{// s is assigned "ABC",}§
+s = string( "ABC   " ).trim( " ", last );       §\C{// s is assigned "ABC",}§
 \end{cfa}
 
@@ -2656 +2651 @@
 returns a string in which all occurrences of the ©from© string in the current string have been replaced by the ©to© string.
 \begin{cfa}
-s = peter.replace( "E", "XX" );         §\C{// s is assigned "PXXTXXR"}§
+s = peter.replace( "E", "XX" ); §\C{// s is assigned "PXXTXXR"}§
 \end{cfa}
 The replacement is done left-to-right.
 When an instance of the ©from© string is found and changed to the ©to© string, it is NOT examined again for further replacement.
 
-\subsection{Returning N+1 on Failure}
+
+\section{Returning N+1 on Failure}
 
 Any of the string search routines can fail at some point during the search.
@@ -2691 +2687 @@
 
 
-\subsection{C Compatibility}
-
-To ease conversion from C to \CFA, there are companion ©string© routines for C strings.
-\VRef[Table]{t:CompanionStringRoutines} shows the C routines on the left that also work with ©string© and the rough equivalent ©string© opeation of the right.
-Hence, it is possible to directly convert a block of C string operations into @string@ just by changing the 
-
-\begin{table}
-\begin{cquote}
-\begin{tabular}{@{}l|l@{}}
-\multicolumn{1}{c|}{©char []©}  & \multicolumn{1}{c}{©string©}  \\
-\hline
-©strcpy©, ©strncpy©             & ©=©                                                                   \\
-©strcat©, ©strncat©             & ©+©                                                                   \\
-©strcmp©, ©strncmp©             & ©==©, ©!=©, ©<©, ©<=©, ©>©, ©>=©              \\
-©strlen©                                & ©size©                                                                \\
-©[]©                                    & ©[]©                                                                  \\
-©strstr©                                & ©find©                                                                \\
-©strcspn©                               & ©find_first_of©, ©find_last_of©               \\
-©strspc©                                & ©find_fist_not_of©, ©find_last_not_of©
-\end{tabular}
-\end{cquote}
-\caption{Companion Routines for \CFA \lstinline{string} to C Strings}
-\label{t:CompanionStringRoutines}
-\end{table}
-
-For example, this block of C code can be converted to \CFA by simply changing the type of variable ©s© from ©char []© to ©string©.
-\begin{cfa}
-        char s[32];
-        //string s;
-        strcpy( s, "abc" );                             PRINT( %s, s );
-        strncpy( s, "abcdef", 3 );              PRINT( %s, s );
-        strcat( s, "xyz" );                             PRINT( %s, s );
-        strncat( s, "uvwxyz", 3 );              PRINT( %s, s );
-        PRINT( %zd, strlen( s ) );
-        PRINT( %c, s[3] );
-        PRINT( %s, strstr( s, "yzu" ) ) ;
-        PRINT( %s, strstr( s, 'y' ) ) ;
-\end{cfa}
-However, the conversion fails with I/O because ©printf© cannot print a ©string© using format code ©%s© because \CFA strings are not null terminated.
-
-
 \subsection{Input/Output Operators}
 
@@ -2752 +2707 @@
 Hence, enums may be overloaded with variable, enum, and function names.
 \begin{cfa}
-int Foo;                                                        §\C{// type/variable separate namespaces}§
+int Foo;                        §\C{// type/variable separate namespaces}§
 enum Foo { Bar };
-enum Goo { Bar };                                       §\C{// overload Foo.Bar}§
-double Bar;                                                     §\C{// overload Foo.Bar, Goo.Bar}§
+enum Goo { Bar };       §\C[1.75in]{// overload Foo.Bar}§
+double Bar;                     §\C{// overload Foo.Bar, Goo.Bar}\CRT§
 \end{cfa}
 An anonymous enumeration injects enums with specific values into a scope.
@@ -2828 +2783 @@
 The following examples illustrate the difference between the enumeration type and the type of its enums.
 \begin{cfa}
-Math m = PI;                                            §\C{// allowed}§
-double d = PI;                                          §\C{// allowed, conversion to base type}§
-m = E;                                                          §\C{// allowed}§
-m = Alph;                                                       §\C{// {\color{red}disallowed}}§
-m = 3.141597;                                           §\C{// {\color{red}disallowed}}§
-d = m;                                                          §\C{// allowed}§
-d = Alph;                                                       §\C{// {\color{red}disallowed}}§
-Letter l = A;                                           §\C{// allowed}§
-Greek g = Alph;                                         §\C{// allowed}§
-l = Alph;                                                       §\C{// allowed, conversion to base type}§
-g = A;                                                          §\C{// {\color{red}disallowed}}§
+Math m = PI;    §\C[1.5in]{// allowed}§
+double d = PI;  §\C{// allowed, conversion to base type}§
+m = E;                  §\C{// allowed}§
+m = Alph;               §\C{// {\color{red}disallowed}}§
+m = 3.141597;   §\C{// {\color{red}disallowed}}§
+d = m;                  §\C{// allowed}§
+d = Alph;               §\C{// {\color{red}disallowed}}§
+Letter l = A;   §\C{// allowed}§
+Greek g = Alph; §\C{// allowed}§
+l = Alph;               §\C{// allowed, conversion to base type}§
+g = A;                  §\C{// {\color{red}disallowed}}\CRT§
 \end{cfa}
 
@@ -3407 +3362 @@
 For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value.
 \begin{cfa}
-typedef struct { int quot, rem; } div_t; §\C{// from include stdlib.h}§
+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}§
+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}
@@ -3420 +3375 @@
 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 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}§
@@ -3449 +3404 @@
 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.
@@ -3461 +3416 @@
 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}§
+[ 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}§
+[ double, double ] modf( double x ); §\C{// from include math}§
 printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§
 \end{cfa}
@@ -3475 +3430 @@
 \begin{cfa}
 int quot, rem;
-[ quot, rem ] = div( 13, 5 );                   §\C{// assign multiple variables}§
-printf( "%d %d\n", quot, rem );                 §\C{// print quotient/remainder}§
+[ 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.
@@ -3893 +3848 @@
 The general syntax of a lexical list is:
 \begin{cfa}
-[ §\emph{exprlist}§ ]
-\end{cfa}
-where \LstBasicStyle{\emph{exprlist}} is a list of one or more expressions separated by commas.
+[ $\emph{exprlist}$ ]
+\end{cfa}
+where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
 The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator.
 The following are examples of lexical lists:
@@ -3901 +3856 @@
 [ x, y, z ]
 [ 2 ]
-[ v + w, x * y, 3.14159, f() ]
+[ v+w, x*y, 3.14159, f() ]
 \end{cfa}
 Tuples are permitted to contain sub-tuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple.
@@ -3913 +3868 @@
 The general syntax of a tuple type is:
 \begin{cfa}
-[ §\emph{typelist}§ ]
-\end{cfa}
-where \LstBasicStyle{\emph{typelist}} is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
+[ $\emph{typelist}$ ]
+\end{cfa}
+where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
 Examples of tuple types include:
 \begin{cfa}
 [ 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}
@@ -3927 +3882 @@
 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}
@@ -3945 +3900 @@
 [ int, int ] w1;
 [ int, int, int ] w2;
-[ void ] f (int, int, int);                             §\C{// three input parameters of type int}§
-[ void ] g ([ int, int, int ]);                 §\C{// 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 );
@@ -4027 +3982 @@
 [ 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;
@@ -4045 +4000 @@
 Mass assignment has the following form:
 \begin{cfa}
-[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
+[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$;
 \end{cfa}
 \index{lvalue}
-The left-hand side is a tuple of \LstBasicStyle{\emph{lvalues}}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement.
-\LstBasicStyle{\emph{expr}} is any standard arithmetic expression.
+The left-hand side is a tuple of \emph{lvalues}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement.
+©$\emph{expr}$© is any standard arithmetic expression.
 Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
 
@@ -4086 +4041 @@
 Multiple assignment has the following form:
 \begin{cfa}
-[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
+[ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$ ];
 \end{cfa}
 \index{lvalue}
@@ -4117 +4072 @@
 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 right-hand side of multiple assignment}§
+f( x++, x++ ); §\C{// C routine call with side effects in arguments}§
+[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in right-hand side of multiple assignment}§
 \end{cfa}
 
@@ -4128 +4083 @@
 Cascade assignment has the following form:
 \begin{cfa}
-§\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;
+$\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$;
 \end{cfa}
 and it has the same parallel semantics as for mass and multiple assignment.
@@ -4148 +4103 @@
 The goal of \CFA stream 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.
 Stream I/O can be implicitly or explicitly formatted.
-Implicit formatting means \CFA selects an I/O format for values that matches a variable's type.
-Explicit formatting means additional I/O information is specified to control how a value is interpreted.
-
+Implicit formatting means \CFA selects the output or input format for values that matches the variable's type.
+Explicit formatting means additional information is specified to augment how an output or input of value is interpreted.
 \CFA formatting incorporates ideas from C ©printf©, \CC ©stream© manipulators, and Python implicit spacing and newline.
 Specifically:
@@ -4158 +4112 @@
 \CFA/\CC format manipulators are named, making them easier to read and remember.
 \item
-©printf©/Python separate format codes from associated variables, making it difficult to match codes with variables.
+©printf©/Python 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 ©printf©/Python/\CFA have local effect, whereas \CC have global effect, except ©setw©.
-Hence, it is common \CC programming practice to toggle manipulators on and then back to the default to prevent downstream side-effects.
+Format manipulators in \CFA have local effect, whereas \CC have global 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.
 Furthermore, to guarantee no side-effects, manipulator values must be saved and restored across function calls.
-\CC programers never do any of this.
 \item
 \CFA has more sophisticated implicit value spacing than Python, plus implicit newline at the end of a print.
 \end{itemize}
 
+The standard polymorphic I/Os stream are ©stdin©/©sin© (input), ©stdout©/©sout© and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©).
+Polymorphic streams ©exit© and ©abort© provide implicit program termination without and with generating a stack trace and core file.
+Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell.
+\begin{cfa}
+®exit®   | "x (" | x | ") negative value.";   // terminate and return EXIT_FAILURE to shell
+®abort® | "x (" | x | ") negative value.";   // terminate and generate stack trace and core file
+\end{cfa}
+Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
+The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
+
 
 \subsection{Basic I/O}
-
-The standard polymorphic I/O streams are ©stdin©/©sin© (input), ©stdout©/©sout©, and ©stderr©/©serr© (output) (like C++ ©cin©/©cout©/©cerr©).
-The standard I/O operator is the bit-wise (or) operator, ©'|'©, which is used to cascade multiple I/O operations.
-The \CFA header file for the I/O library is \Indexc{fstream.hfa}.
 
 For implicit formatted output, the common case is printing a series of variables separated by whitespace.
@@ -4218 +4177 @@
 1®, ®2®, ®3 4®, ®5®, ®6
 \end{cfa}
-The bit-wise ©|© operator is used for I/O, rather \CC shift-operators, ©<<© and ©>>©, as it is the lowest-priority \emph{overloadable} operator, other than assignment.
-(Operators ©||© and ©&&© are not overloadable in \CFA.)
+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}
@@ -4242 +4200 @@
 \end{cquote}
 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.
-Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators to prevent this common error in \CC:
+Input and output use a uniform operator, ©|©, rather than \CC's ©<<© and ©>>© input/output operators, which prevents this common error in \CC:
 \begin{C++}
 cin << i; // why is this generating a lot of error messages?
 \end{C++}
-
-Streams ©exit© and ©abort© provide output with immediate program termination without and with generating a stack trace and core file.
-Stream ©exit© implicitly returns ©EXIT_FAILURE© to the shell.
-\begin{cfa}
-®exit®   | "x (" | x | ") negative value.";     §\C{// print, terminate, and return EXIT\_FAILURE to shell}§
-®abort® | "x (" | x | ") negative value.";      §\C{// print, terminate, and generate stack trace and core file}§
-\end{cfa}
-Note, \CFA stream variables ©stdin©, ©stdout©, ©stderr©, ©exit©, and ©abort© overload C variables ©stdin©, ©stdout©, ©stderr©, and functions ©exit© and ©abort©, respectively.
 
 For implicit formatted 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.
@@ -4296 +4246 @@
 \end{tabular}
 \end{cquote}
-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©.
-In all cases, all whitespace characters are skipped until an appropriate value is found.
-\Textbf{If an appropriate value is not found, the exception ©missing_data© is raised.}
-
-For the C-string type, there are two input forms: any number of \Textbf{non-whitespace} characters or a quoted sequence containing any characters except the closing quote, \ie there is no escape character supported in the string..
-In both cases, the string is null terminated ©'\0'©.
-For the quoted string, the start and end quote characters can be any character and do not have to match \see{\ref{XXX}}.
-
-\VRef[Figure]{f:IOStreamFunctions} shows the I/O stream operations for interacting with files other than ©cin©, ©cout©, and ©cerr©.
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set.
-\item
-\Indexc{clear} resets the stream error-indicator.
-\item
-\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file.
-\item
-\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream.
-Returns true if the end-of-file indicator is set, otherwise false.
-\item
-\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©).
-\item
-\Indexc{close} flushes the stream and closes the file.
-\item
-\Indexc{write} (©ofstream© only) writes ©size© bytes to the stream.
-The bytes are written lazily when an internal buffer fills.
-Eager buffer writes are done with ©flush©
-\item
-\Indexc{read} (©ifstream© only) reads ©size© bytes from the stream.
-\item
-\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream.
-Pushed-back characters returned by subsequent reads in the reverse order of pushing.
-\end{itemize}
-The constructor functions:
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-create an unbound stream, which is subsequently bound to a file with ©open©.
-\item
-create a bound stream to the associated file with given ©mode©.
-\end{itemize}
-The destructor closes the stream.
-
-\begin{figure}
-\begin{cfa}
-// *********************************** ofstream ***********************************
-bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§
-void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§
-int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§
-void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§
-void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§
-ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§
-void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§
-void ?{}( ofstream &, const char name[], const char mode[] = "w" );
-void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§
-
-// *********************************** ifstream ***********************************
-bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§
-void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§
-bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§
-void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§
-void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§
-ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§
-ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§
-void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§
-void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
-void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§
-\end{cfa}
-\caption{I/O Stream Functions}
-\label{f:IOStreamFunctions}
-\end{figure}
-
-\VRef[Figure]{f:CFACommand-LineProcessing} demonstrates the file operations by showing the idiomatic \CFA command-line processing and copying an input file to an output file.
+
+\VRef[Figure]{f:CFACommand-LineProcessing} shows idiomatic \CFA command-line processing and copying an input file to an output file.
 Note, a stream variable may be copied because it is a reference to an underlying stream data-structures.
-\Textbf{All I/O errors are handled as exceptions}, but end-of-file is not an exception as C programmers are use to explicitly checking for it.
+All I/O errors are handles as exceptions, but end-of-file is not an exception as C programmers are use to explicitly checking for it.
 
 \begin{figure}
@@ -4393 +4261 @@
         try {
                 choose ( argc ) {
-                  case 3, 2:
+                  case 2, 3:
                         ®open®( in, argv[1] );                  §\C{// open input file first as output creates file}§
                         if ( argc == 3 ) ®open®( out, argv[2] ); §\C{// do not create output unless input opens}§
@@ -4422 +4290 @@
 \end{figure}
 
+\VRef[Figure]{f:StreamFunctions} shows the stream operations.
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+\Indexc{fail} tests the stream error-indicator, returning nonzero if it is set.
+\item
+\Indexc{clear} resets the stream error-indicator.
+\item
+\Indexc{flush} (©ofstream© only) causes any unwritten data for a stream to be written to the file.
+\item
+\Indexc{eof} (©ifstream© only) tests the end-of-file indicator for the stream pointed to by stream.
+Returns true if the end-of-file indicator is set, otherwise false.
+\item
+\Indexc{open} binds the file with ©name© to a stream accessed with ©mode© (see ©fopen©).
+\item
+\Indexc{close} flushes the stream and closes the file.
+\item
+\Indexc{write} (©ofstream© only) writes ©size© bytes to the stream.
+The bytes are written lazily when an internal buffer fills.
+Eager buffer writes are done with ©flush©
+\item
+\Indexc{read} (©ifstream© only) reads ©size© bytes from the stream.
+\item
+\Indexc{ungetc} (©ifstream© only) pushes the character back to the input stream.
+Pushed-back characters returned by subsequent reads in the reverse order of pushing.
+\end{itemize}
+The constructor functions:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+create an unbound stream, which is subsequently bound to a file with ©open©.
+\item
+create a bound stream to the associated file with given ©mode©.
+\end{itemize}
+The destructor closes the stream.
+
+\begin{figure}
+\begin{cfa}
+// *********************************** ofstream ***********************************
+
+bool fail( ofstream & );§\indexc{fail}\index{ofstream@©ofstream©!©fail©}§
+void clear( ofstream & );§\indexc{clear}\index{ofstream@©ofstream©!©clear©}§
+int flush( ofstream & );§\indexc{flush}\index{ofstream@©ofstream©!©flush©}§
+void open( ofstream &, const char name[], const char mode[] = "w" );§\indexc{open}\index{ofstream@©ofstream©!©open©}§
+void close( ofstream & );§\indexc{close}\index{ofstream@©ofstream©!©close©}§
+ofstream & write( ofstream &, const char data[], size_t size );§\indexc{write}\index{ofstream@©ofstream©!©write©}§
+
+void ?{}( ofstream & );§\index{ofstream@©ofstream©!©?{}©}§
+void ?{}( ofstream &, const char name[], const char mode[] = "w" );
+void ^?{}( ofstream & );§\index{ofstream@©ofstream©!©^?{}©}§
+
+// *********************************** ifstream ***********************************
+
+bool fail( ifstream & is );§\indexc{fail}\index{ifstream@©ifstream©!©fail©}§
+void clear( ifstream & );§\indexc{clear}\index{ifstream@©ifstream©!©clear©}§
+bool eof( ifstream & is );§\indexc{eof}\index{ifstream@©ifstream©!©eof©}§
+void open( ifstream & is, const char name[], const char mode[] = "r" );§\indexc{open}\index{ifstream@©ifstream©!©open©}§
+void close( ifstream & is );§\indexc{close}\index{ifstream@©ifstream©!©close©}§
+ifstream & read( ifstream & is, char data[], size_t size );§\indexc{read}\index{ifstream@©ifstream©!©read©}§
+ifstream & ungetc( ifstream & is, char c );§\indexc{unget}\index{ifstream@©ifstream©!©unget©}§
+
+void ?{}( ifstream & is );§\index{ifstream@©ifstream©!©?{}©}§
+void ?{}( ifstream & is, const char name[], const char mode[] = "r" );
+void ^?{}( ifstream & is );§\index{ifstream@©ifstream©!©^?{}©}§
+\end{cfa}
+\caption{Stream Functions}
+\label{f:StreamFunctions}
+\end{figure}
+
 
 \subsection{Implicit Separator}
 
 The \Index{implicit separator}\index{I/O!separator} character (space/blank) is a separator not a terminator for output.
-The rules for implicitly adding a separator are:
+The rules for implicitly adding the separator are:
 \begin{enumerate}
 \item
@@ -4455 +4390 @@
 \begin{cfa}
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
-           | 7 | "§\LstStringStyle{\textcent}§ x" | 8 | "§\LstStringStyle{\guillemotright}§ x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
+           | 7 | "$\LstStringStyle{\textcent}$ x" | 8 | "$\LstStringStyle{\guillemotright}$ x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
 \end{cfa}
 \begin{cfa}[showspaces=true]
-Input1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\R{\LstStringStyle{\textcent}}§ x 8§\R{\LstStringStyle{\guillemotright}}§ x 9®)® x 10®]® x 11®}® x
+1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9®)® x 10®]® x 11®}® x
 \end{cfa}
 
 \item
 A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{([\{=\$\textsterling\textyen\textexclamdown\textquestiondown\guillemotleft}, where \LstStringStyle{\textexclamdown\textquestiondown} are inverted opening exclamation and question marks, and \LstStringStyle{\guillemotleft} is an opening citation mark.
-\begin{cfa}
-sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x §\LstStringStyle{\textdollar}§" | 5 | "x §\LstStringStyle{\textsterling}§" | 6 | "x §\LstStringStyle{\textyen}§"
-           | 7 | "x §\LstStringStyle{\textexclamdown}§" | 8 | "x §\LstStringStyle{\textquestiondown}§" | 9 | "x §\LstStringStyle{\guillemotleft}§" | 10;
-\end{cfa}
+%$
+\begin{cfa}
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
+           | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
+\end{cfa}
+%$
 \begin{cfa}[showspaces=true]
-x ®(®1 x ®[®2 x ®{®3 x ®=®4 x §\LstStringStyle{\textdollar}§5 x §\R{\LstStringStyle{\textsterling}}§6 x §\R{\LstStringStyle{\textyen}}§7 x §\R{\LstStringStyle{\textexclamdown}}§8 x §\R{\LstStringStyle{\textquestiondown}}§9 x §\R{\LstStringStyle{\guillemotleft}}§10
-\end{cfa}
+x ®(®1 x ®[®2 x ®{®3 x ®=®4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
+\end{cfa}
+%$
 
 \item
@@ -4477 +4415 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
-x®`®1®`®x§\R{\texttt{'}}§2§\R{\texttt{'}}§x§\R{\texttt{"}}§3§\R{\texttt{"}}§x®:®4®:®x® ®5® ®x®  ®6®     ®x
+x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
 \end{cfa}
 
@@ -4483 +4421 @@
 If a space is desired before or after one of the special string start/end characters, explicitly insert a space.
 \begin{cfa}
-sout | "x (§\R{\texttt{\textvisiblespace}}§" | 1 | "§\R{\texttt{\textvisiblespace}}§) x" | 2 | "§\R{\texttt{\textvisiblespace}}§, x" | 3 | "§\R{\texttt{\textvisiblespace}}§:x:§\R{\texttt{\textvisiblespace}}§" | 4;
+sout | "x ($\R{\texttt{\textvisiblespace}}$" | 1 | "$\R{\texttt{\textvisiblespace}}$) x" | 2 | "$\R{\texttt{\textvisiblespace}}$, x" | 3 | "$\R{\texttt{\textvisiblespace}}$:x:$\R{\texttt{\textvisiblespace}}$" | 4;
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
@@ -4500 +4438 @@
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, ", §\LstStringStyle{\textdollar}§" ); §\C{// set separator from " " to ", \$"}§
+sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); §\C{// set separator from " " to ", \$"}§
 sout | 1 | 2 | 3 | " \"" | ®sepVal® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1®, §\color{red}\LstStringStyle{\textdollar}§®2®, §\color{red}\LstStringStyle{\textdollar}§®3 ®", §\color{red}\LstStringStyle{\textdollar}§"®
+1®, $\color{red}\LstStringStyle{\textdollar}$®2®, $\color{red}\LstStringStyle{\textdollar}$®3 ®", $\color{red}\LstStringStyle{\textdollar}$"®
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
@@ -4619 +4557 @@
 For example, in:
 \begin{cfa}
-int i, j;
 sin | i | ®nl® | j;
 1 ®2®
@@ -4625 +4562 @@
 \end{cfa}
 variable ©i© is assigned 1, the 2 is skipped, and variable ©j© is assigned 3.
-For example, in:
-\begin{cquote}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\begin{cfa}
-char ch
-
-sin | ch; // read X
-
-X
-\end{cfa}
-&
-\begin{cfa}
-
-sin | ®nlOn®; // enable reading newlines
-sin | ch; // read newline
-
-
-\end{cfa}
-\end{tabular}
-\end{cquote}
-the left example skips the newline and reads ©'X'© into ©ch©, while the right example reads the newline into ©ch©.
 
 For output:
@@ -4673 +4589 @@
 
 
-\subsection{Output Manipulators}
+\subsection{Output Value Manipulators}
 
 The following \Index{manipulator}s control formatting (printing) of the argument output values.
@@ -4727 +4643 @@
 \item
 \Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
-\begin{cquote}
 ©y© $\Rightarrow 10^{-24}$, ©z© $\Rightarrow 10^{-21}$, ©a© $\Rightarrow 10^{-18}$, ©f© $\Rightarrow 10^{-15}$, ©p© $\Rightarrow 10^{-12}$, ©n© $\Rightarrow 10^{-9}$, ©u© $\Rightarrow 10^{-6}$, ©m© $\Rightarrow 10^{-3}$, ©K© $\Rightarrow 10^{3}$, ©M© $\Rightarrow 10^{6}$, ©G© $\Rightarrow 10^{9}$, ©T© $\Rightarrow 10^{12}$, ©P© $\Rightarrow 10^{15}$, ©E© $\Rightarrow 10^{18}$, ©Z© $\Rightarrow 10^{21}$, ©Y© $\Rightarrow 10^{24}$.
-\end{cquote}
 For exponent $10^{0}$, no decimal point or letter is printed.
 \begin{cfa}[belowskip=0pt]
@@ -4929 +4843 @@
 // End: //
 \end{comment}
-
-
-\subsection{Input Manipulators}
-
-The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument.
-
-Certain manipulators support a \newterm{scanset}, which is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus.
-For example, the scanset \lstinline{"a-zA-Z -/?§"} matches any number of characters between ©'a'© and ©'z'©, between ©'A'© and ©'Z'©, between space and ©'/'©, and characters ©'?'© and (Latin-1) ©'§'©.
+%$
+
+
+\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.
+To force programmers to consider buffer overruns for C-string input, C-strings can only be read with a width field, which should specify a size less than or equal to the C-string size, \eg:
+\begin{cfa}
+char line[64];
+sin | wdi( ®sizeof(line)®, line ); // must specify size
+\end{cfa}
+
+A scanset is a simple regular expression, where the matching set contains any Latin-1 character (8-bits) or character ranges using minus.
+For example, the scanset \lstinline{"a-zA-Z -/?§"} matches characters between ©'a'© and ©'z'©, between ©'A'© and ©'Z'©, between space and ©'/'©, and characters ©'?'© and (Latin-1) ©'§'©.
 The following string is matched by this scanset:
 \begin{cfa}
-!&%$  abAA () ZZZ  ??  xx§\S\S\S§
+!&%$  abAA () ZZZ  ??  xx§§§§
 \end{cfa}
 To match a minus, put it as the first character, ©"-0-9"©.
 Other complex forms of regular-expression matching are not supported.
 
-A string variable \emph{must} be large enough to contain the input sequence.
-To force programmers to consider buffer overruns for C-string input, C-strings can only be read with a width field, which should specify a size less than or equal to the C-string size, \eg:
-\begin{cfa}
-char line[64];
-sin | wdi( ®sizeof(line)®, line ); // must specify size
-\end{cfa}
-
-Currently, there is no mechanism to detect if a value read exceeds the capwhen Most types are finite sized, \eg integral types only store value that fit into their corresponding storage, 8, 16, 32, 64, 128 bits.
-Hence, an input value may be too large, and the result of the read is often considered undefined, which leads to difficlt to locate runtime errors.
-All reads in \CFA check if values do not fit into the argument variable's type and raise the exception 
-All types are
-
+The following \Index{manipulator}s control scanning of input values (reading), and only affect the format of the argument.
 \begin{enumerate}
 \item
-\Indexc{skip}( scanset )\index{manipulator!skip@©skip©}, ©skip©( $N$ )
-The first form uses a scanset to skip matching characters.
-The second form skips the next $N$ characters, including newline.
+\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( 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";
+char sk[$\,$] = "abc";
 sin | "abc " | skip( sk ) | skip( 5 ); // match input sequence
 \end{cfa}
@@ -4974 +4899 @@
 
 \item
-\Indexc{wdi}( maximum, variable )\index{manipulator!wdi@©wdi©}
-For all types except ©char *©, whitespace is skipped until an appropriate value is found for the specified variable type.
-maximum is the maximum number of characters read for the current operation.
+\Indexc{wdi}( maximum, reference-value )\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 ch;   char ca[3];   int i;   double d;   
-sin | wdi( sizeof(ch), ch ) | wdi( sizeof(ca), ca[0] ) | wdi( 3, i ) | wdi( 8, d );  // c == 'a', ca == "bcd", i == 123, d == 345.6
+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}
-Here, ©ca[0]© is type ©char©, so the width reads 3 characters \Textbf{without} a null terminator.
-
 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{wdi}( maximum size, ©char s[]© )\index{manipulator!wdi@©wdi©}
-For type ©char *©, maximum is the maximum number of characters read for the current operation.
-Any number of non-whitespace characters, stopping at the first whitespace character found. A terminating null character is automatically added at the end of the stored sequence
-\begin{cfa}[belowskip=0pt]
-char cstr[10];
-sin | wdi( sizeof(cstr), cstr );
-\end{cfa}
-\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®abcd1233.456E+2®
-\end{cfa}
-
-\item
-\Indexc{wdi}( maximum size, maximum read, ©char s[]© )\index{manipulator!wdi@©wdi©}
-For type ©char *©, maximum is the maximum number of characters read for the current operation.
-\begin{cfa}[belowskip=0pt]
-char ch;   char ca[3];   int i;   double d;   
-sin | wdi( sizeof(ch), ch ) | wdi( sizeof(ca), ca[0] ) | wdi( 3, i ) | wdi( 8, d );  // c == 'a', ca == "bcd", i == 123, d == 345.6
-\end{cfa}
-\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-®abcd1233.456E+2®
-\end{cfa}
 
 \item
@@ -5047 +4946 @@
 \end{cfa}
 
-\Indexc{quoted}( char delimit, wdi-input-string )\index{manipulator!quoted@©quoted©}
-Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
-If the delimit character is omitted, it defaults to ©'\n'© (newline).
-
 \item
 \Indexc{getline}( char delimit, wdi-input-string )\index{manipulator!getline@©getline©}
-Is an ©excl© with scanset ©"delimit"©, which consumes all characters up to the delimit character.
+Is an @excl@ with scanset ©"delimit"©, which consumes all characters up to the delimit character.
 If the delimit character is omitted, it defaults to ©'\n'© (newline).
 \end{enumerate}
@@ -5063 +4958 @@
 For example, if two threads execute the following:
 \begin{cfa}
-§\emph{thread\(_1\)}§ : sout | "abc " | "def ";
-§\emph{thread\(_2\)}§ : sout | "uvw " | "xyz ";
+$\emph{thread\(_1\)}$ : sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz ";
 \end{cfa}
 possible outputs are:
@@ -5104 +4999 @@
 The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg:
 \begin{cfa}
-§\emph{thread\(_1\)}§ : ®mutex( sout )® sout | "abc " | "def ";
-§\emph{thread\(_2\)}§ : ®mutex( sout )® sout | "uvw " | "xyz ";
+$\emph{thread\(_1\)}$ : ®mutex( sout )® sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : ®mutex( sout )® sout | "uvw " | "xyz ";
 \end{cfa}
 Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
@@ -5166 +5061 @@
 Cultures use different syntax, called a \newterm{locale}, for printing numbers so they are easier to read, \eg:
 \begin{cfa}
-12®,®345®.®123          §\C[1.25in]{// comma separator, period decimal-point}§
+12®,®345®.®123          $\C[1.25in]{// comma separator, period decimal-point}$
 12®.®345®,®123          §\C{// period separator, comma decimal-point}§
-12§\Sp§345®,®123®.®     §\C{// space separator, comma decimal-point, period terminator}\CRT§
+12$\Sp$345®,®123®.®     §\C{// space separator, comma decimal-point, period terminator}\CRT§
 \end{cfa}
 A locale is selected with function ©setlocale©, and the corresponding locale package \emph{must} be installed on the underlying system;
@@ -5214 +5109 @@
 Ukraine uk_UA.utf8
 12 123 1 234 12 345 123 456 1 234 567
-12®.® 123®,®1®.® 1§\Sp§234®,®12®.® 12§\Sp§ 345®,®123®.® 123§\Sp§ 456®,®1234®.® 1§\Sp§ 234§\Sp§567®,®12345®.®
+12®.® 123®,®1®.® 1$\Sp$234®,®12®.® 12$\Sp$ 345®,®123®.® 123$\Sp$ 456®,®1234®.® 1$\Sp$ 234$\Sp$567®,®12345®.®
 
 Default locale off C
@@ -5566 +5461 @@
 
 \subsection{Operator}
-\label{s:Operator}
 
 \CFA also allows operators to be overloaded, to simplify the use of user-defined types.
@@ -7438 +7332 @@
 
 \Index*[C++]{\CC{}} is a general-purpose programming language.
-It is an imperative, object-oriented and generic programming language, while also providing facilities for low-level memory manipulation.
-The primary focus of \CC was adding object-oriented programming to C, and this is the primary difference between \CC and \CFA.
+It has imperative, object-oriented and generic programming features, while also providing facilities for low-level memory manipulation. (Wikipedia)
+
+The primary focus of \CC seems to be adding object-oriented programming to C, and this is the primary difference between \CC and Do.
 \CC uses classes to encapsulate data and the functions that operate on that data, and to hide the internal representation of the data.
 \CFA uses modules instead to perform these same tasks.
@@ -7457 +7352 @@
 \subsection{Go}
 
-\Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007~\cite{Go}.
+\Index*{Go}, also commonly referred to as golang, is a programming language developed at Google in 2007 [.].
 It is a statically typed language with syntax loosely derived from that of C, adding garbage collection, type
 safety, some structural typing capabilities, additional built-in types such as variable-length arrays and key-value maps, and a large standard library. (Wikipedia)
@@ -7511 +7406 @@
 In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as:
 \begin{cfa}
-*?§\Sp§*?                                                               §\C{// dereference operator, dereference operator}§
-*§\Sp§?*?                                                               §\C{// dereference, multiplication operator}§
+*?$\Sp$*? §\C{// dereference operator, dereference operator}§
+*$\Sp$?*? §\C{// dereference, multiplication operator}§
 \end{cfa}
 By default, the first interpretation is selected, which does not yield a meaningful parse.
@@ -7521 +7416 @@
 The ambiguity occurs when the deference operator has no parameters:
 \begin{cfa}
-*?()§\R{\textvisiblespace...}§ ;
-*?()§\R{\textvisiblespace...}§(...) ;
+*?()$\R{\textvisiblespace...}$ ;
+*?()$\R{\textvisiblespace...}$(...) ;
 \end{cfa}
 requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
@@ -7530 +7425 @@
 The remaining cases are with the increment/decrement operators and conditional expression, \eg:
 \begin{cfa}
-i++?§\R{\textvisiblespace...}§(...);
-i?++§\R{\textvisiblespace...}§(...);
+i++?$\R{\textvisiblespace...}$(...);
+i?++$\R{\textvisiblespace...}$(...);
 \end{cfa}
 requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an incorrect expression (juxtaposed identifiers).
 Therefore, it is necessary to disambiguate these cases with a space:
 \begin{cfa}
-i++§\Sp§? i : 0;
-i?§\Sp§++i : 0;
+i++$\Sp$? i : 0;
+i?$\Sp$++i : 0;
 \end{cfa}
 
@@ -7564 +7459 @@
 \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}§
 {
         ...
@@ -7591 +7486 @@
 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.
@@ -7613 +7508 @@
 \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©.
@@ -7621 +7516 @@
 \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.
@@ -7633 +7528 @@
 \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.
@@ -7641 +7536 @@
 \begin{cfa}
 struct X { int i; struct X *next; };
-static struct X a;                              §\C{// forward definition}§
-static struct X b = { 0, ®&a® }; §\C{// forward reference, valid in C, invalid in \CFA}§
-static struct X a = { 1, &b };  §\C{// definition}§
+static struct X a; §\C{// forward definition}§
+static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
+static struct X a = { 1, &b }; §\C{// definition}§
 \end{cfa}
 \item[Rationale:] avoids having different initialization rules for builtin types and user-defined types.
@@ -7657 +7552 @@
 enum ®Colour® { R, G, B, Y, C, M };
 struct Person {
-        enum ®Colour® { R, G, B };      §\C{// nested type}§
-        struct Face {                           §\C{// nested type}§
-                ®Colour® Eyes, Hair;    §\C{// type defined outside (1 level)}§
+        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
+        struct Face { §\C{// nested type}§
+                ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§
         };
-        ®.Colour® shirt;                        §\C{// type defined outside (top level)}§
-        ®Colour® pants;                         §\C{// type defined same level}§
-        Face looks[10];                         §\C{// type defined same level}§
+        ®.Colour® shirt; §\C{// type defined outside (top level)}§
+        ®Colour® pants; §\C{// type defined same level}§
+        Face looks[10]; §\C{// type defined same level}§
 };
-®Colour® c = R;                                 §\C{// type/enum defined same level}§
-Person®.Colour® pc = Person®.®R;        §\C{// type/enum defined inside}§
-Person®.®Face pretty;                   §\C{// type defined inside}§
+®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§
 \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.
@@ -7744 +7639 @@
 \CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers.
 
-\begin{cquote}
-\Indexc{basetypeof}, \Indexc{choose}, \Indexc{coroutine}, \Indexc{disable},
-\Indexc{enable}, \Indexc{exception}, \Indexc{fallthrough}, \Indexc{fallthru},
-\Indexc{finally}, \Indexc{fixup}, \Indexc{forall},\Indexc{generator},
-\Indexc{int128}, \Indexc{monitor}, \Indexc{mutex}, \Indexc{one_t},
-\Indexc{report}, \Indexc{suspend}, \Indexc{throw}, \Indexc{throwResume},
-\Indexc{trait}, \Indexc{try}, \Indexc{virtual}, \Indexc{waitfor},
-\Indexc{when}, \Indexc{with}, \Indexc{zero_t}
-\end{cquote}
-\CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers.
-\begin{cquote}
-\Indexc{catch}, \Indexc{catchResume}, \Indexc{finally}, \Indexc{fixup}, \Indexc{or}, \Indexc{timeout}
-\end{cquote}
-
-\begin{comment}
 \begin{cquote}
 \begin{tabular}{@{}lllllll@{}}
@@ -7827 +7707 @@
 \end{tabular}
 \end{cquote}
-\end{comment}
-
 
 \section{Standard Headers}
 \label{s:StandardHeaders}
 
-\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11}:
-\begin{cquote}
-\Indexc{assert.h}, \Indexc{complex.h}, \Indexc{ctype.h}, \Indexc{errno.h}, \Indexc{fenv.h},
-\Indexc[deletekeywords=float]{float.h}, \Indexc{inttypes.h}, \Indexc{iso646.h}, \Indexc{limits.h},
-\Indexc{locale.h}, \Indexc{math.h}, \Indexc{setjmp.h}, \Indexc{signal.h}, \Indexc{stdalign.h},
-\Indexc{stdarg.h}, \Indexc{stdatomic.h}, \Indexc{stdbool.h}, \Indexc{stddef.h}, \Indexc{stdint.h},
-\Indexc{stdio.h}, \Indexc{stdlib.h}, \Indexc{stdnoreturn.h}, \Indexc{string.h}, \Indexc{tgmath.h},
-\Indexc{threads.h}, \Indexc{time.h}, \Indexc{uchar.h}, \Indexc{wchar.h}, \Indexc{wctype.h}
-\end{cquote}
-and \CFA adds to this list:
-\begin{cquote}
-\Indexc{gmp.h}, \Indexc{malloc.h}, \Indexc{unistd.h}
-\end{cquote}
-\begin{comment}
+\Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{cquote}
 \begin{tabular}{@{}llllll|l@{}}
@@ -7908 +7773 @@
 \end{tabular}
 \end{cquote}
-\end{comment}
 For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
 hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}.
@@ -7973 +7837 @@
 Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in
 \begin{cfa}
-int * ip = (int *)malloc( sizeof(int) ); §\C{// C}§
-int * ip = malloc();                                    §\C{// \CFA type-safe version of C malloc}§
-int * ip = alloc();                                             §\C{// \CFA type-safe uniform alloc}§
+int * ip = (int *)malloc( sizeof(int) );                §\C{// C}§
+int * ip = malloc();                                                    §\C{// \CFA type-safe version of C malloc}§
+int * ip = alloc();                                                             §\C{// \CFA type-safe uniform alloc}§
 \end{cfa}
 the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©.
@@ -7982 +7846 @@
 \begin{cfa}
 struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment
-S * sp = malloc();                                              §\C{// honour type alignment}§
+S * sp = malloc();                                                              §\C{// honour type alignment}§
 \end{cfa}
 the storage allocation is implicitly aligned to 128 rather than the default 16.
@@ -7997 +7861 @@
 \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
 \begin{cfa}
-struct S { int i; };                                    §\C{// cache-line alignment}§
+struct S { int i; };                                                    §\C{// cache-line alignment}§
 void ?{}( S & s, int i ) { s.i = i; }
 // assume ?|? operator for printing an S
 
-S & sp = *®new®( 3 );                                   §\C{// call constructor after allocation}§
+S & sp = *®new®( 3 );                                                   §\C{// call constructor after allocation}§
 sout | sp.i;
 ®delete®( &sp );
 
-S * spa = ®anew®( 10, 5 );                              §\C{// allocate array and initialize each array element}§
+S * spa = ®anew®( 10, 5 );                                              §\C{// allocate array and initialize each array element}§
 for ( i; 10 ) sout | spa[i] | nonl;
 sout | nl;
@@ -8017 +7881 @@
 extern "C" {
         // C unsafe allocation
-        void * malloc( size_t size );§\indexc{malloc}§
-        void * calloc( size_t dim, size_t size );§\indexc{calloc}§
-        void * realloc( void * ptr, size_t size );§\indexc{realloc}§
-        void * memalign( size_t align, size_t size );§\indexc{memalign}§
-        void * aligned_alloc( size_t align, size_t size );§\indexc{aligned_alloc}§
-        int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
-        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );§\indexc{cmemalign}§ // CFA
+        void * malloc( size_t size );$\indexc{malloc}$
+        void * calloc( size_t dim, size_t size );$\indexc{calloc}$
+        void * realloc( void * ptr, size_t size );$\indexc{realloc}$
+        void * memalign( size_t align, size_t size );$\indexc{memalign}$
+        void * aligned_alloc( size_t align, size_t size );$\indexc{aligned_alloc}$
+        int posix_memalign( void ** ptr, size_t align, size_t size );$\indexc{posix_memalign}$
+        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );$\indexc{cmemalign}$ // CFA
 
         // C unsafe initialization/copy
-        void * memset( void * dest, int c, size_t size );§\indexc{memset}§
-        void * memcpy( void * dest, const void * src, size_t size );§\indexc{memcpy}§
+        void * memset( void * dest, int c, size_t size );$\indexc{memset}$
+        void * memcpy( void * dest, const void * src, size_t size );$\indexc{memcpy}$
 }
 
@@ -8033 +7897 @@
 
 forall( dtype T | sized(T) ) {
-        // §\CFA§ safe equivalents, i.e., implicit size specification
+        // $\CFA$ safe equivalents, i.e., implicit size specification
         T * malloc( void );
         T * calloc( size_t dim );
@@ -8042 +7906 @@
         int posix_memalign( T ** ptr, size_t align );
 
-        // §\CFA§ safe general allocation, fill, resize, alignment, array
-        T * alloc( void );§\indexc{alloc}§                                      §\C[3.5in]{// variable, T size}§
+        // $\CFA$ safe general allocation, fill, resize, alignment, array
+        T * alloc( void );$\indexc{alloc}$                                      $\C[3.5in]{// variable, T size}$
         T * alloc( size_t dim );                                                        §\C{// array[dim], T size elements}§
         T * alloc( T ptr[], size_t dim );                                       §\C{// realloc array[dim], T size elements}§
 
-        T * alloc_set( char fill );§\indexc{alloc_set}§         §\C{// variable, T size, fill bytes with value}§
+        T * alloc_set( char fill );$\indexc{alloc_set}$         §\C{// variable, T size, fill bytes with value}§
         T * alloc_set( T fill );                                                        §\C{// variable, T size, fill with value}§
         T * alloc_set( size_t dim, char fill );                         §\C{// array[dim], T size elements, fill bytes with value}§
@@ -8066 +7930 @@
         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§
 
-        // §\CFA§ safe initialization/copy, i.e., implicit size specification
-        T * memset( T * dest, char fill );§\indexc{memset}§
-        T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
-
-        // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types
+        // $\CFA$ safe initialization/copy, i.e., implicit size specification
+        T * memset( T * dest, char fill );$\indexc{memset}$
+        T * memcpy( T * dest, const T * src );$\indexc{memcpy}$
+
+        // $\CFA$ safe initialization/copy, i.e., implicit size specification, array types
         T * amemset( T dest[], char fill, size_t dim );
         T * amemcpy( T dest[], const T src[], size_t dim );
 }
 
-// §\CFA§ allocation/deallocation and constructor/destructor, non-array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );§\indexc{new}§
-forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );§\indexc{delete}§
+// $\CFA$ allocation/deallocation and constructor/destructor, non-array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );$\indexc{new}$
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );$\indexc{delete}$
 forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
   void delete( T * ptr, Params rest );
 
-// §\CFA§ allocation/deallocation and constructor/destructor, array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
-forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
+// $\CFA$ allocation/deallocation and constructor/destructor, array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );$\indexc{anew}$
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );$\indexc{adelete}$
 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
   void adelete( size_t dim, T arr[], Params rest );
@@ -8093 +7957 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-int ato( const char * ptr );§\indexc{ato}§
+int ato( const char * ptr );$\indexc{ato}$
 unsigned int ato( const char * ptr );
 long int ato( const char * ptr );
@@ -8126 +7990 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 forall( T | { int ?<?( T, T ); } ) §\C{// location}§
-T * bsearch( T key, const T * arr, size_t dim );§\indexc{bsearch}§
+T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$
 
 forall( T | { int ?<?( T, T ); } ) §\C{// position}§
@@ -8132 +7996 @@
 
 forall( T | { int ?<?( T, T ); } )
-void qsort( const T * arr, size_t dim );§\indexc{qsort}§
+void qsort( const T * arr, size_t dim );$\indexc{qsort}$
 
 forall( 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}§
+        E * bsearchl( E key, const E * vals, size_t dim );$\indexc{bsearchl}$
         size_t bsearchl( E key, const E * vals, size_t dim );
-        E * bsearchu( E key, const E * vals, size_t dim );§\indexc{bsearchu}§
+        E * bsearchu( E key, const E * vals, size_t dim );$\indexc{bsearchu}$
         size_t bsearchu( E key, const E * vals, size_t dim );
 }
@@ -8153 +8017 @@
 
 forall( E | { int ?<?( E, E ); } ) {
-        void qsort( E * vals, size_t dim );§\indexc{qsort}§
+        void qsort( E * vals, size_t dim );$\indexc{qsort}$
 }
 \end{cfa}
@@ -8162 +8026 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-unsigned char abs( signed char );§\indexc{abs}§
+unsigned char abs( signed char );$\indexc{abs}$
 int abs( int );
 unsigned long int abs( long int );
@@ -8177 +8041 @@
 
 
-\subsection{C Random Numbers}
+\subsection{Random Numbers}
 
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-void srandom( unsigned int seed );§\indexc{srandom}§
-char random( void );§\indexc{random}§
+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]}§
@@ -8209 +8073 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-forall( T | { int ?<?( T, T ); } ) T min( T t1, T t2 );§\indexc{min}§
-forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 );§\indexc{max}§
-forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );§\indexc{clamp}§
-forall( T ) void swap( T * t1, T * t2 );§\indexc{swap}§
+forall( T | { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$
+forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$
+forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$
+forall( T ) void swap( T * t1, T * t2 );$\indexc{swap}$
 \end{cfa}
 
@@ -8226 +8090 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float ?%?( float, float );§\indexc{fmod}§
+float ?%?( float, float );$\indexc{fmod}$
 float fmod( float, float );
 double ?%?( double, double );
@@ -8233 +8097 @@
 long double fmod( long double, long double );
 
-float remainder( float, float );§\indexc{remainder}§
+float remainder( float, float );$\indexc{remainder}$
 double remainder( double, double );
 long double remainder( long double, long double );
 
-float remquo( float, float, int * );§\indexc{remquo}§
+float remquo( float, float, int * );$\indexc{remquo}$
 double remquo( double, double, int * );
 long double remquo( long double, long double, int * );
@@ -8248 +8112 @@
 [ int, long double ] div( long double, long double );
 
-float fma( float, float, float );§\indexc{fma}§
+float fma( float, float, float );$\indexc{fma}$
 double fma( double, double, double );
 long double fma( long double, long double, long double );
 
-float fdim( float, float );§\indexc{fdim}§
+float fdim( float, float );$\indexc{fdim}$
 double fdim( double, double );
 long double fdim( long double, long double );
 
-float nan( const char * );§\indexc{nan}§
+float nan( const char * );$\indexc{nan}$
 double nan( const char * );
 long double nan( const char * );
@@ -8266 +8130 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float exp( float );§\indexc{exp}§
+float exp( float );$\indexc{exp}$
 double exp( double );
 long double exp( long double );
@@ -8273 +8137 @@
 long double _Complex exp( long double _Complex );
 
-float exp2( float );§\indexc{exp2}§
+float exp2( float );$\indexc{exp2}$
 double exp2( double );
 long double exp2( long double );
@@ -8280 +8144 @@
 // long double _Complex exp2( long double _Complex );
 
-float expm1( float );§\indexc{expm1}§
+float expm1( float );$\indexc{expm1}$
 double expm1( double );
 long double expm1( long double );
 
-float pow( float, float );§\indexc{pow}§
+float pow( float, float );$\indexc{pow}$
 double pow( double, double );
 long double pow( long double, long double );
@@ -8297 +8161 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float log( float );§\indexc{log}§
+float log( float );$\indexc{log}$
 double log( double );
 long double log( long double );
@@ -8304 +8168 @@
 long double _Complex log( long double _Complex );
 
-int log2( unsigned int );§\indexc{log2}§
+int log2( unsigned int );$\indexc{log2}$
 long int log2( unsigned long int );
 long long int log2( unsigned long long int )
@@ -8314 +8178 @@
 // long double _Complex log2( long double _Complex );
 
-float log10( float );§\indexc{log10}§
+float log10( float );$\indexc{log10}$
 double log10( double );
 long double log10( long double );
@@ -8321 +8185 @@
 // long double _Complex log10( long double _Complex );
 
-float log1p( float );§\indexc{log1p}§
+float log1p( float );$\indexc{log1p}$
 double log1p( double );
 long double log1p( long double );
 
-int ilogb( float );§\indexc{ilogb}§
+int ilogb( float );$\indexc{ilogb}$
 int ilogb( double );
 int ilogb( long double );
 
-float logb( float );§\indexc{logb}§
+float logb( float );$\indexc{logb}$
 double logb( double );
 long double logb( long double );
 
-float sqrt( float );§\indexc{sqrt}§
+float sqrt( float );$\indexc{sqrt}$
 double sqrt( double );
 long double sqrt( long double );
@@ -8340 +8204 @@
 long double _Complex sqrt( long double _Complex );
 
-float cbrt( float );§\indexc{cbrt}§
+float cbrt( float );$\indexc{cbrt}$
 double cbrt( double );
 long double cbrt( long double );
 
-float hypot( float, float );§\indexc{hypot}§
+float hypot( float, float );$\indexc{hypot}$
 double hypot( double, double );
 long double hypot( long double, long double );
@@ -8354 +8218 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float sin( float );§\indexc{sin}§
+float sin( float );$\indexc{sin}$
 double sin( double );
 long double sin( long double );
@@ -8361 +8225 @@
 long double _Complex sin( long double _Complex );
 
-float cos( float );§\indexc{cos}§
+float cos( float );$\indexc{cos}$
 double cos( double );
 long double cos( long double );
@@ -8368 +8232 @@
 long double _Complex cos( long double _Complex );
 
-float tan( float );§\indexc{tan}§
+float tan( float );$\indexc{tan}$
 double tan( double );
 long double tan( long double );
@@ -8375 +8239 @@
 long double _Complex tan( long double _Complex );
 
-float asin( float );§\indexc{asin}§
+float asin( float );$\indexc{asin}$
 double asin( double );
 long double asin( long double );
@@ -8382 +8246 @@
 long double _Complex asin( long double _Complex );
 
-float acos( float );§\indexc{acos}§
+float acos( float );$\indexc{acos}$
 double acos( double );
 long double acos( long double );
@@ -8389 +8253 @@
 long double _Complex acos( long double _Complex );
 
-float atan( float );§\indexc{atan}§
+float atan( float );$\indexc{atan}$
 double atan( double );
 long double atan( long double );
@@ -8396 +8260 @@
 long double _Complex atan( long double _Complex );
 
-float atan2( float, float );§\indexc{atan2}§
+float atan2( float, float );$\indexc{atan2}$
 double atan2( double, double );
 long double atan2( long double, long double );
 
 float atan( float, float ); §\C{// alternative name for atan2}§
-double atan( double, double );§\indexc{atan}§
+double atan( double, double );$\indexc{atan}$
 long double atan( long double, long double );
 \end{cfa}
@@ -8410 +8274 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float sinh( float );§\indexc{sinh}§
+float sinh( float );$\indexc{sinh}$
 double sinh( double );
 long double sinh( long double );
@@ -8417 +8281 @@
 long double _Complex sinh( long double _Complex );
 
-float cosh( float );§\indexc{cosh}§
+float cosh( float );$\indexc{cosh}$
 double cosh( double );
 long double cosh( long double );
@@ -8424 +8288 @@
 long double _Complex cosh( long double _Complex );
 
-float tanh( float );§\indexc{tanh}§
+float tanh( float );$\indexc{tanh}$
 double tanh( double );
 long double tanh( long double );
@@ -8431 +8295 @@
 long double _Complex tanh( long double _Complex );
 
-float asinh( float );§\indexc{asinh}§
+float asinh( float );$\indexc{asinh}$
 double asinh( double );
 long double asinh( long double );
@@ -8438 +8302 @@
 long double _Complex asinh( long double _Complex );
 
-float acosh( float );§\indexc{acosh}§
+float acosh( float );$\indexc{acosh}$
 double acosh( double );
 long double acosh( long double );
@@ -8445 +8309 @@
 long double _Complex acosh( long double _Complex );
 
-float atanh( float );§\indexc{atanh}§
+float atanh( float );$\indexc{atanh}$
 double atanh( double );
 long double atanh( long double );
@@ -8458 +8322 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float erf( float );§\indexc{erf}§
+float erf( float );$\indexc{erf}$
 double erf( double );
 long double erf( long double );
@@ -8465 +8329 @@
 long double _Complex erf( long double _Complex );
 
-float erfc( float );§\indexc{erfc}§
+float erfc( float );$\indexc{erfc}$
 double erfc( double );
 long double erfc( long double );
@@ -8472 +8336 @@
 long double _Complex erfc( long double _Complex );
 
-float lgamma( float );§\indexc{lgamma}§
+float lgamma( float );$\indexc{lgamma}$
 double lgamma( double );
 long double lgamma( long double );
@@ -8479 +8343 @@
 long double lgamma( long double, int * );
 
-float tgamma( float );§\indexc{tgamma}§
+float tgamma( float );$\indexc{tgamma}$
 double tgamma( double );
 long double tgamma( long double );
@@ -8525 +8389 @@
 unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
 
-float floor( float );§\indexc{floor}§
+float floor( float );$\indexc{floor}$
 double floor( double );
 long double floor( long double );
 
-float ceil( float );§\indexc{ceil}§
+float ceil( float );$\indexc{ceil}$
 double ceil( double );
 long double ceil( long double );
 
-float trunc( float );§\indexc{trunc}§
+float trunc( float );$\indexc{trunc}$
 double trunc( double );
 long double trunc( long double );
 
-float rint( float );§\indexc{rint}§
+float rint( float );$\indexc{rint}$
 long double rint( long double );
 long int rint( float );
@@ -8546 +8410 @@
 long long int rint( long double );
 
-long int lrint( float );§\indexc{lrint}§
+long int lrint( float );$\indexc{lrint}$
 long int lrint( double );
 long int lrint( long double );
@@ -8553 +8417 @@
 long long int llrint( long double );
 
-float nearbyint( float );§\indexc{nearbyint}§
+float nearbyint( float );$\indexc{nearbyint}$
 double nearbyint( double );
 long double nearbyint( long double );
 
-float round( float );§\indexc{round}§
+float round( float );$\indexc{round}$
 long double round( long double );
 long int round( float );
@@ -8566 +8430 @@
 long long int round( long double );
 
-long int lround( float );§\indexc{lround}§
+long int lround( float );$\indexc{lround}$
 long int lround( double );
 long int lround( long double );
@@ -8579 +8443 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-float copysign( float, float );§\indexc{copysign}§
+float copysign( float, float );$\indexc{copysign}$
 double copysign( double, double );
 long double copysign( long double, long double );
 
-float frexp( float, int * );§\indexc{frexp}§
+float frexp( float, int * );$\indexc{frexp}$
 double frexp( double, int * );
 long double frexp( long double, int * );
 
-float ldexp( float, int );§\indexc{ldexp}§
+float ldexp( float, int );$\indexc{ldexp}$
 double ldexp( double, int );
 long double ldexp( long double, int );
 
-[ float, float ] modf( float );§\indexc{modf}§
+[ float, float ] modf( float );$\indexc{modf}$
 float modf( float, float * );
 [ double, double ] modf( double );
@@ -8598 +8462 @@
 long double modf( long double, long double * );
 
-float nextafter( float, float );§\indexc{nextafter}§
+float nextafter( float, float );$\indexc{nextafter}$
 double nextafter( double, double );
 long double nextafter( long double, long double );
 
-float nexttoward( float, long double );§\indexc{nexttoward}§
+float nexttoward( float, long double );$\indexc{nexttoward}$
 double nexttoward( double, long double );
 long double nexttoward( long double, long double );
 
-float scalbn( float, int );§\indexc{scalbn}§
+float scalbn( float, int );$\indexc{scalbn}$
 double scalbn( double, int );
 long double scalbn( long double, int );
 
-float scalbln( float, long int );§\indexc{scalbln}§
+float scalbln( float, long int );$\indexc{scalbln}$
 double scalbln( double, long int );
 long double scalbln( long double, long int );
@@ -8870 +8734 @@
 All \newterm{pseudo random-number generators} (\newterm{PRNG}) involve some technique to scramble bits of a value, \eg multiplicative recurrence:
 \begin{cfa}
-rand = 33967 * (rand + 1063); // scramble bits
+rand = 36973 * (rand & 65535) + (rand >> 16); // scramble bits
 \end{cfa}
 Multiplication of large values adds new least-significant bits and drops most-significant bits.
@@ -8877 +8741 @@
 bits 63--32 (most)      & bits 31--0 (least)    \\
 \hline
-©0x0©                           & ©0x3e8e36©                    \\
-©0x5f©                          & ©0x718c25e1©                  \\
-©0xad3e©                        & ©0x7b5f1dbe©                  \\
-©0xbc3b©                        & ©0xac69ff19©                  \\
-©0x1070f©                       & ©0x2d258dc6©
+0x0                                     & 0x3e8e36                              \\
+0x5f                            & 0x718c25e1                    \\
+0xad3e                          & 0x7b5f1dbe                    \\
+0xbc3b                          & 0xac69ff19                    \\
+0x1070f                         & 0x2d258dc6                    \\
 \end{tabular}
 \end{quote}
@@ -8887 +8751 @@
 The least-significant bits \emph{appear} random but the same bits are always generated given a fixed starting value, called the \newterm{seed} (value 0x3e8e36 above).
 Hence, if a program uses the same seed, the same sequence of pseudo-random values is generated from the PRNG.
-Often the seed is set to another random value like a program's process identifier (\Indexc{getpid}) or time when the program is run;
+Often the seed is set to another random value like a program's process identifier (©getpid©\index{getpid@©getpid©}) or time when the program is run;
 hence, one random value bootstraps another.
 Finally, a PRNG usually generates a range of large values, \eg ©[0, UINT_MAX]©, which are scaled using the modulus operator, \eg ©prng() % 5© produces random values in the range 0--4.
 
-\CFA provides 32/64-bit sequential PRNG type only accessible by a single thread (not thread-safe) and a set of global routines and companion thread PRNG functions accessible by multiple threads without contention.
-To use the PRNG interface \Textbf{requires including \Indexc{stdlib.hfa}}.
+\CFA provides a sequential PRNG type only accessible by a single thread (not thread-safe) and a set of global and companion thread PRNG functions accessible by multiple threads without contention.
 \begin{itemize}
 \item
-The ©PRNG© types for sequential programs, including coroutining, are:
-\begin{cfa}
-struct PRNG32 {};                                               §\C{// opaque type, no copy or assignment}§
-void ?{}( PRNG32 & prng, uint32_t seed ); §\C{// fixed seed}§
-void ?{}( PRNG32 & prng );                              §\C{// random seed}§
-void set_seed( PRNG32 & prng, uint32_t seed ); §\C{// set seed}§
-uint32_t get_seed( PRNG32 & prng );             §\C{// get seed}§
-uint32_t prng( PRNG32 & prng );                 §\C{// [0,UINT\_MAX]}§
-uint32_t prng( PRNG32 & prng, uint32_t u ); §\C{// [0,u)}§
-uint32_t prng( PRNG32 & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§
-uint32_t calls( PRNG32 & prng );                §\C{// number of calls}§
-void copy( PRNG32 & dst, PRNG32 & src ); §\C{// checkpoint PRNG state}§
-\end{cfa}
-\begin{cfa}
-struct PRNG64 {};                                               §\C{// opaque type, no copy or assignment}§
-void ?{}( PRNG64 & prng, uint64_t seed ); §\C{// fixed seed}§
-void ?{}( PRNG64 & prng );                              §\C{// random seed}§
-void set_seed( PRNG64 & prng, uint64_t seed ); §\C{// set seed}§
-uint64_t get_seed( PRNG64 & prng );             §\C{// get seed}§
-uint64_t prng( PRNG64 & prng );                 §\C{// [0,UINT\_MAX]}§
-uint64_t prng( PRNG64 & prng, uint64_t u ); §\C{// [0,u)}§
-uint64_t prng( PRNG64 & prng, uint64_t l, uint64_t u ); §\C{// [l,u]}§
-uint64_t calls( PRNG64 & prng );                §\C{// number of calls}§
-void copy( PRNG64 & dst, PRNG64 & src ); §\C{// checkpoint PRNG state}§
-\end{cfa}
-The type ©PRNG© is aliased to ©PRNG64© on 64-bit architectures and ©PRNG32© on 32-bit architectures.
+The ©PRNG© type is for sequential programs, like coroutining:
+\begin{cfa}
+struct PRNG { ... }; $\C[3.75in]{// opaque type}$
+void ?{}( PRNG & prng ); §\C{// random seed}§
+void ?{}( PRNG & prng, uint32_t seed ); §\C{// fixed seed}§
+void set_seed( PRNG & prng, uint32_t seed ); §\C{// set seed}§
+uint32_t get_seed( PRNG & prng ); §\C{// get seed}§
+uint32_t prng( PRNG & prng ); §\C{// [0,UINT\_MAX]}§
+uint32_t prng( PRNG & prng, uint32_t u ); §\C{// [0,u)}§
+uint32_t prng( PRNG & prng, uint32_t l, uint32_t u ); §\C{// [l,u]}§
+uint32_t calls( PRNG & prng ); §\C{// number of calls}\CRT§
+\end{cfa}
 A ©PRNG© object is used to randomize behaviour or values during execution, \eg in games, a character makes a random move or an object takes on a random value.
 In this scenario, it is useful to have multiple ©PRNG© objects, \eg one per player or object.
-However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s.
+However, sequential execution is still repeatable given the same starting seeds for all ©PRNG©s. 
 \VRef[Figure]{f:SequentialPRNG} shows an example that creates two sequential ©PRNG©s, sets both to the same seed (1009), and illustrates the three forms for generating random values, where both ©PRNG©s generate the same sequence of values.
-Note, to prevent accidental PRNG copying, the copy constructor and assignment are hidden.
-To copy a PRNG for checkpointing, use the explicit ©copy© member.
 
 \begin{figure}
 \begin{cfa}
-PRNG sprng1, sprng2;                                    §\C{// select appropriate 32/64-bit PRNG}§
-®set_seed( sprng1, 1009 )®;   ®set_seed( sprng2, 1009 )®;
+PRNG prng1, prng2;
+®set_seed( prng1, 1009 )®;   ®set_seed( prng2, 1009 )®;
 for ( 10 ) {
         // Do not cascade prng calls because side-effect functions called in arbitrary order.
-        sout | nlOff | ®prng( sprng1 )®;  sout | ®prng( sprng1, 5 )®;  sout | ®prng( sprng1, 0, 5 )® | '\t';
-        sout | ®prng( sprng2 )®;  sout | ®prng( sprng2, 5 )®;  sout | ®prng( sprng2, 0, 5 )® | nlOn;
+        sout | nlOff | ®prng( prng1 )®;  sout | ®prng( prng1, 5 )®;  sout | ®prng( prng1, 0, 5 )® | '\t';
+        sout | ®prng( prng2 )®;  sout | ®prng( prng2, 5 )®;  sout | ®prng( prng2, 0, 5 )® | nlOn;
 }
 \end{cfa}
@@ -8974 +8821 @@
 The PRNG global and companion thread functions are for concurrent programming, such as randomizing execution in short-running programs, \eg ©yield( prng() % 5 )©.
 \begin{cfa}
-void set_seed( size_t seed );                   §\C{// set global seed}§
-size_t get_seed();                                              §\C{// get global seed}§
-// SLOWER, global routines
-size_t prng( void );                                    §\C{// [0,UINT\_MAX]}§
-size_t prng( size_t u );                                §\C{// [0,u)}§
-size_t prng( size_t l, size_t u );              §\C{// [l,u]}§
-// FASTER, thread members
-size_t prng( §thread\LstStringStyle{\textdollar}§ & th );       §\C{// [0,UINT\_MAX]}§
-size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t u );     §\C{// [0,u)}§
-size_t prng( §thread\LstStringStyle{\textdollar}§ & th, size_t l, size_t u );   §\C{// [l,u]}§
+void set_seed( uint32_t seed ); $\C[3.75in]{// set global seed}$
+uint32_t get_seed(); §\C{// get global seed}§
+// SLOWER
+uint32_t prng(); §\C{// [0,UINT\_MAX]}§
+uint32_t prng( uint32_t u ); §\C{// [0,u)}§
+uint32_t prng( uint32_t l, uint32_t u ); §\C{// [l,u]}§
+// FASTER
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th );     §\C{// [0,UINT\_MAX]}§
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t u ); §\C{// [0,u)}§
+uint32_t prng( $thread\LstStringStyle{\textdollar}$ & th, uint32_t l, uint32_t u );     §\C{// [l,u]}\CRT§
 \end{cfa}
 The only difference between the two sets of ©prng© routines is performance.
@@ -8994 +8841 @@
 Hence, these threads generate different sequences of random numbers.
 If each thread needs its own seed, use a sequential ©PRNG© in each thread.
-The slower ©prng© global functions, \ie \emph{without} a thread argument, call ©active_thread© internally to indirectly access the current thread's PRNG state, while the faster ©prng© functions, \ie \emph{with} a thread argument, directly access the thread through the thread parameter.
+The slower ©prng© functions \emph{without} a thread argument call ©active_thread© internally to indirectly access the current thread's PRNG state, while the faster ©prng© functions \emph{with} a thread argument directly access the thread through the thread parameter.
 If a thread pointer is available, \eg in thread main, eliminating the call to ©active_thread© significantly reduces the cost of accessing the thread's PRNG state.
 \VRef[Figure]{f:ConcurrentPRNG} shows an example using the slower/faster concurrent PRNG in the program main and a thread.
@@ -9009 +8856 @@
 int main() {
         set_seed( 1009 );
-        §\R{thread\LstStringStyle{\textdollar}}§ ®& th = *active_thread()®;  // program-main thread-address
+        $\R{thread\LstStringStyle{\textdollar}}$ ®& th = *active_thread()®;  // program-main thread-address
         for ( i; 10 ) {
                 sout | nlOff | ®prng()®; sout | ®prng( 5 )®; sout | ®prng( 0, 5 )® | '\t';  // SLOWER
@@ -9232 +9079 @@
 \hline
 \begin{cfa}
-#include <gmp.h>§\indexc{gmp.h}§
+#include <gmp.h>$\indexc{gmp.h}$
 int main( void ) {
         ®gmp_printf®( "Factorial Numbers\n" );
@@ -9246 +9093 @@
 &
 \begin{cfa}
-#include <gmp.hfa>§\indexc{gmp}§
+#include <gmp.hfa>$\indexc{gmp}$
 int main( void ) {
         sout | "Factorial Numbers";
@@ -9318 +9165 @@
 \begin{cfa}[belowskip=0pt]
 // implementation
-struct Rational {§\indexc{Rational}§
+struct Rational {$\indexc{Rational}$
         long int numerator, denominator; §\C{// invariant: denominator > 0}§
 }; // Rational