Changeset 5407cdc for doc/user/user.tex


Ignore:
Timestamp:
Apr 28, 2021, 4:56:50 PM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
8d66610
Parents:
feacef9 (diff), b7fd2db6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/user/user.tex

    rfeacef9 r5407cdc  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Mon Feb 15 13:48:53 2021
    14 %% Update Count     : 4452
     13%% Last Modified On : Sun Apr 25 19:03:03 2021
     14%% Update Count     : 4951
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    6666% math escape $...$ (dollar symbol)
    6767\input{common}                                          % common CFA document macros
     68\setlength{\gcolumnposn}{3in}
    6869\CFAStyle                                                                                               % use default CFA format-style
    6970\lstset{language=CFA}                                                                   % CFA default lnaguage
    7071\lstnewenvironment{C++}[1][]                            % use C++ style
    71 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}}
     72{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
    7273{}
    7374
    … …  
    8182\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
    8283\newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
    83 \newcommand{\R}[1]{\Textbf{#1}}
    84 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}
     84\newcommand{\R}[1]{{\color{red}#1}}
     85\newcommand{\RB}[1]{\Textbf{#1}}
    8586\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
    8687\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
    … …  
    176177int main( void ) {
    177178        int x = 0, y = 1, z = 2;
    178         @printf( "%d %d %d\n", x, y, z );@
     179        ®printf( "%d %d %d\n", x, y, z );®
    179180}
    180181\end{cfa}
    … …  
    185186int main( void ) {
    186187        int x = 0, y = 1, z = 2;
    187         @sout | x | y | z;@$\indexc{sout}$
     188        ®sout | x | y | z;®$\indexc{sout}$
    188189}
    189190\end{cfa}
    … …  
    194195int main() {
    195196        int x = 0, y = 1, z = 2;
    196         @cout<<x<<" "<<y<<" "<<z<<endl;@
     197        ®cout<<x<<" "<<y<<" "<<z<<endl;®
    197198}
    198199\end{cfa}
    … …  
    224225\begin{tabular}{@{}rcccccccc@{}}
    225226                & 2021  & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986  \\ \hline
    226 \R{C}   & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\
     227\RB{C}  & \RB{1}& \RB{2}& \RB{2}& \RB{1}& \RB{1}& \RB{1}& \RB{1}& \RB{1}\\
    227228Java    & 2             & 1             & 1             & 2             & 3             & 28    & -             & -             \\
    228229Python  & 3             & 5             & 6             & 7             & 23    & 13    & -             & -             \\
    … …  
    258259The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
    259260\begin{cfa}
    260 @forall( otype T )@ T identity( T val ) { return val; }
     261®forall( otype T )® T identity( T val ) { return val; }
    261262int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
    262263\end{cfa}
    … …  
    322323Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
    323324\begin{cfa}
    324 char @abs@( char );
    325 extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$
    326 long int @abs@( long int );
    327 long long int @abs@( long long int );
    328 float @abs@( float );
    329 double @abs@( double );
    330 long double @abs@( long double );
    331 float _Complex @abs@( float _Complex );
    332 double _Complex @abs@( double _Complex );
    333 long double _Complex @abs@( long double _Complex );
     325char ®abs®( char );
     326extern "C" { int ®abs®( int ); } $\C{// use default C routine for int}$
     327long int ®abs®( long int );
     328long long int ®abs®( long long int );
     329float ®abs®( float );
     330double ®abs®( double );
     331long double ®abs®( long double );
     332float _Complex ®abs®( float _Complex );
     333double _Complex ®abs®( double _Complex );
     334long double _Complex ®abs®( long double _Complex );
    334335\end{cfa}
    335336The problem is \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).
    … …  
    358359The 2011 C standard plus GNU extensions.
    359360\item
    360 \Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
     361\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]{-fgnu89-inline}}}
    361362Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
    362363\end{description}
    … …  
    530531Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
    531532\begin{cfa}
    532 int @``@otype = 3; $\C{// make keyword an identifier}$
    533 double @``@forall = 3.5;
     533int ®``®otype = 3; $\C{// make keyword an identifier}$
     534double ®``®forall = 3.5;
    534535\end{cfa}
    535536
    … …  
    542543// include file uses the CFA keyword "with".
    543544#if ! defined( with )                                                   $\C{// nesting ?}$
    544 #define with @``@with                                                   $\C{// make keyword an identifier}$
     545#define with ®``®with                                                   $\C{// make keyword an identifier}$
    545546#define __CFA_BFD_H__
    546547#endif
    … …  
    560561Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
    561562\begin{cfa}
    562 2@_@147@_@483@_@648; $\C{// decimal constant}$
    563 56@_@ul; $\C{// decimal unsigned long constant}$
    564 0@_@377; $\C{// octal constant}$
    565 0x@_@ff@_@ff; $\C{// hexadecimal constant}$
    566 0x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$
    567 3.141@_@592@_@654; $\C{// floating constant}$
    568 10@_@e@_@+1@_@00; $\C{// floating constant}$
    569 0x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$
    570 0x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$
    571 L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$
     5632®_®147®_®483®_®648; $\C{// decimal constant}$
     56456®_®ul; $\C{// decimal unsigned long constant}$
     5650®_®377; $\C{// octal constant}$
     5660x®_®ff®_®ff; $\C{// hexadecimal constant}$
     5670x®_®ef3d®_®aa5c; $\C{// hexadecimal constant}$
     5683.141®_®592®_®654; $\C{// floating constant}$
     56910®_®e®_®+1®_®00; $\C{// floating constant}$
     5700x®_®ff®_®ff®_®p®_®3; $\C{// hexadecimal floating}$
     5710x®_®1.ffff®_®ffff®_®p®_®128®_®l; $\C{// hexadecimal floating long constant}$
     572L®_®$"\texttt{\textbackslash{x}}$®_®$\texttt{ff}$®_®$\texttt{ee}"$; $\C{// wide character constant}$
    572573\end{cfa}
    573574The rules for placement of underscores are:
    … …  
    602603Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
    603604\begin{cfa}
    604 sout | 1 @\@ 0 | 1 @\@ 1 | 2 @\@ 8 | -4 @\@ 3 | 5 @\@ 3 | 5 @\@ 32 | 5L @\@ 32 | 5L @\@ 64 | -4 @\@ -3 | -4.0 @\@ -3 | 4.0 @\@ 2.1
    605            | (1.0f+2.0fi) @\@ (3.0f+2.0fi);
    606 1 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@ -0.015625 18.3791736799526 0.264715-1.1922i
     605sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
     606           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
     6071 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
    607608\end{cfa}
    608609Note, ©5 \ 32© and ©5L \ 64© overflow, and ©-4 \ -3© is a fraction but stored in an integer so all three computations generate an integral zero.
    … …  
    612613\begin{cfa}
    613614forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
    614 T ?@\@?( T ep, unsigned int y );
     615T ?®\®?( T ep, unsigned int y );
    615616forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
    616 T ?@\@?( T ep, unsigned long int y );
     617T ?®\®?( T ep, unsigned long int y );
    617618\end{cfa}
    618619The user type ©T© must define multiplication, one (©1©), and ©*©.
    … …  
    624625
    625626
    626 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
     627%\subsection{\texorpdfstring{\protect\lstinline{if}/\protect\lstinline{while} Statement}{if Statement}}
    627628\subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
    628629
    … …  
    630631Declarations in the ©do©-©while© condition are not useful because they appear after the loop body.}
    631632\begin{cfa}
    632 if ( @int x = f()@ ) ... $\C{// x != 0}$
    633 if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
    634 if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
    635 if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$
    636 
    637 while ( @int x = f()@ ) ... $\C{// x != 0}$
    638 while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
    639 while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
    640 while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$
     633if ( ®int x = f()® ) ... $\C{// x != 0}$
     634if ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
     635if ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
     636if ( ®struct S { int i; } x = { f() }; x.i < 4® ) $\C{// relational expression}$
     637
     638while ( ®int x = f()® ) ... $\C{// x != 0}$
     639while ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
     640while ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
     641while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... $\C{// relational expression}$
    641642\end{cfa}
    642643Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.
    … …  
    645646
    646647
    647 %\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
     648%\section{\texorpdfstring{\protect\lstinline{case} Clause}{case Clause}}
    648649\subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
    649650\label{s:caseClause}
    … …  
    658659\begin{cfa}
    659660switch ( i ) {
    660   case @1, 3, 5@:
     661  case ®1, 3, 5®:
    661662        ...
    662   case @2, 4, 6@:
     663  case ®2, 4, 6®:
    663664        ...
    664665}
    … …  
    685686\end{cquote}
    686687In addition, subranges are allowed to specify case values.\footnote{
    687 gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
     688gcc has the same mechanism but awkward syntax, \lstinline{2 ...42}, because a space is required after a number, otherwise the period is a decimal point.}
    688689\begin{cfa}
    689690switch ( i ) {
    690   case @1~5:@ $\C{// 1, 2, 3, 4, 5}$
     691  case ®1~5:® $\C{// 1, 2, 3, 4, 5}$
    691692        ...
    692   case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$
     693  case ®10~15:® $\C{// 10, 11, 12, 13, 14, 15}$
    693694        ...
    694695}
    … …  
    696697Lists of subranges are also allowed.
    697698\begin{cfa}
    698 case @1~5, 12~21, 35~42@:
    699 \end{cfa}
    700 
    701 
    702 %\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
     699case ®1~5, 12~21, 35~42®:
     700\end{cfa}
     701
     702
     703%\section{\texorpdfstring{\protect\lstinline{switch} Statement}{switch Statement}}
    703704\subsection{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
    704705
    … …  
    740741if ( argc == 3 ) {
    741742        // open output file
    742         @// open input file
    743 @} else if ( argc == 2 ) {
    744         @// open input file (duplicate)
    745 
    746 @} else {
     743        ®// open input file
     744®} else if ( argc == 2 ) {
     745        ®// open input file (duplicate)
     746
     747®} else {
    747748        // usage message
    748749}
    … …  
    755756\begin{cfa}
    756757switch ( i ) {
    757   @case 1: case 3: case 5:@     // odd values
     758  ®case 1: case 3: case 5:®     // odd values
    758759        // odd action
    759760        break;
    760   @case 2: case 4: case 6:@     // even values
     761  ®case 2: case 4: case 6:®     // even values
    761762        // even action
    762763        break;
    … …  
    774775        if ( j < k ) {
    775776                ...
    776           @case 1:@             // transfer into "if" statement
     777          ®case 1:®             // transfer into "if" statement
    777778                ...
    778779        } // if
    … …  
    780781        while ( j < 5 ) {
    781782                ...
    782           @case 3:@             // transfer into "while" statement
     783          ®case 3:®             // transfer into "while" statement
    783784                ...
    784785        } // while
    … …  
    821822\begin{cfa}
    822823switch ( x ) {
    823         @int y = 1;@ $\C{// unreachable initialization}$
    824         @x = 7;@ $\C{// unreachable code without label/branch}$
     824        ®int y = 1;® $\C{// unreachable initialization}$
     825        ®x = 7;® $\C{// unreachable code without label/branch}$
    825826  case 0: ...
    826827        ...
    827         @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$
     828        ®int z = 0;® $\C{// unreachable initialization, cannot appear after case}$
    828829        z = 2;
    829830  case 1:
    830         @x = z;@ $\C{// without fall through, z is uninitialized}$
     831        ®x = z;® $\C{// without fall through, z is uninitialized}$
    831832}
    832833\end{cfa}
    … …  
    860861Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
    861862\begin{cfa}
    862 @choose@ ( i ) {
     863®choose® ( i ) {
    863864  case 1:  case 2:  case 3:
    864865        ...
    865         @// implicit end of switch (break)
    866   @case 5:
     866        ®// implicit end of switch (break)
     867  ®case 5:
    867868        ...
    868         @fallthru@; $\C{// explicit fall through}$
     869        ®fallthru®; $\C{// explicit fall through}$
    869870  case 7:
    870871        ...
    871         @break@ $\C{// explicit end of switch (redundant)}$
     872        ®break® $\C{// explicit end of switch (redundant)}$
    872873  default:
    873874        j = 3;
    … …  
    890891\begin{cfa}
    891892switch ( x ) {
    892         @int i = 0;@ $\C{// allowed only at start}$
     893        ®int i = 0;® $\C{// allowed only at start}$
    893894  case 0:
    894895        ...
    895         @int j = 0;@ $\C{// disallowed}$
     896        ®int j = 0;® $\C{// disallowed}$
    896897  case 1:
    897898        {
    898                 @int k = 0;@ $\C{// allowed at different nesting levels}$
     899                ®int k = 0;® $\C{// allowed at different nesting levels}$
    899900                ...
    900           @case 2:@ $\C{// disallow case in nested statements}$
     901          ®case 2:® $\C{// disallow case in nested statements}$
    901902        }
    902903  ...
    … …  
    915916  case 3:
    916917        if ( ... ) {
    917                 ... @fallthru;@ // goto case 4
     918                ... ®fallthru;® // goto case 4
    918919        } else {
    919920                ...
    … …  
    930931choose ( ... ) {
    931932  case 3:
    932         ... @fallthrough common;@
     933        ... ®fallthrough common;®
    933934  case 4:
    934         ... @fallthrough common;@
    935 
    936   @common:@ // below fallthrough
     935        ... ®fallthrough common;®
     936
     937  ®common:® // below fallthrough
    937938                          // at case-clause level
    938939        ...     // common code for cases 3/4
    … …  
    950951                for ( ... ) {
    951952                        // multi-level transfer
    952                         ... @fallthru common;@
     953                        ... ®fallthru common;®
    953954                }
    954955                ...
    955956        }
    956957        ...
    957   @common:@ // below fallthrough
     958  ®common:® // below fallthrough
    958959                          // at case-clause level
    959960\end{cfa}
    … …  
    970971\hline
    971972\begin{cfa}
    972 while @($\,$)@ { sout | "empty"; break; }
    973 do { sout | "empty"; break; } while @($\,$)@;
    974 for @($\,$)@ { sout | "empty"; break; }
    975 for ( @0@ ) { sout | "A"; } sout | "zero";
    976 for ( @1@ ) { sout | "A"; }
    977 for ( @10@ ) { sout | "A"; }
    978 for ( @= 10@ ) { sout | "A"; }
    979 for ( @1 ~= 10 ~ 2@ ) { sout | "B"; }
    980 for ( @10 -~= 1 ~ 2@ ) { sout | "C"; }
    981 for ( @0.5 ~ 5.5@ ) { sout | "D"; }
    982 for ( @5.5 -~ 0.5@ ) { sout | "E"; }
    983 for ( @i; 10@ ) { sout | i; }
    984 for ( @i; = 10@ ) { sout | i; }
    985 for ( @i; 1 ~= 10 ~ 2@ ) { sout | i; }
    986 for ( @i; 10 -~= 1 ~ 2@ ) { sout | i; }
    987 for ( @i; 0.5 ~ 5.5@ ) { sout | i; }
    988 for ( @i; 5.5 -~ 0.5@ ) { sout | i; }
    989 for ( @ui; 2u ~= 10u ~ 2u@ ) { sout | ui; }
    990 for ( @ui; 10u -~= 2u ~ 2u@ ) { sout | ui; }
     973while ®($\,$)® { sout | "empty"; break; }
     974do { sout | "empty"; break; } while ®($\,$)®;
     975for ®($\,$)® { sout | "empty"; break; }
     976for ( ®0® ) { sout | "A"; } sout | "zero";
     977for ( ®1® ) { sout | "A"; }
     978for ( ®10® ) { sout | "A"; }
     979for ( ®= 10® ) { sout | "A"; }
     980for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
     981for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
     982for ( ®0.5 ~ 5.5® ) { sout | "D"; }
     983for ( ®5.5 -~ 0.5® ) { sout | "E"; }
     984for ( ®i; 10® ) { sout | i; }
     985for ( ®i; = 10® ) { sout | i; }
     986for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
     987for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
     988for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
     989for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
     990for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
     991for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
    991992enum { N = 10 };
    992 for ( @N@ ) { sout | "N"; }
    993 for ( @i; N@ ) { sout | i; }
    994 for ( @i; N -~ 0@ ) { sout | i; }
     993for ( ®N® ) { sout | "N"; }
     994for ( ®i; N® ) { sout | i; }
     995for ( ®i; N -~ 0® ) { sout | i; }
    995996const int start = 3, comp = 10, inc = 2;
    996 for ( @i; start ~ comp ~ inc + 1@ ) { sout | i; }
    997 for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout | i; }
    998 for ( i; 10 -~ $\R{@}$ ) { if ( i < 0 ) break; sout | i; }
    999 for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout | i; }
    1000 for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
    1001 for ( i; 10 -~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout | i; }
    1002 for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
    1003 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
    1004 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
    1005 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
    1006 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
    1007 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
    1008 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
    1009 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
    1010 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
    1011 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
    1012 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
    1013 for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j | k; }
     997for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
     998for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
     999for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
     1000for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
     1001for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
     1002for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
     1003for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
     1004for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
     1005for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
     1006for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
     1007for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
     1008for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
     1009for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
     1010for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
     1011for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
     1012for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
     1013for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
     1014for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
    10141015\end{cfa}
    10151016&
    … …  
    10891090The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
    10901091\begin{cfa}
    1091 for ( i; @5@ )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
    1092 for ( i; @1.5@~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
     1092for ( i; ®5® )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
     1093for ( i; ®1.5®~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
    10931094\end{cfa}
    10941095\item
    10951096An empty conditional implies comparison value of ©1© (true).
    10961097\begin{cfa}
    1097 while ( $\R{/*empty*/}$ )               $\C{// while ( true )}$
    1098 for ( $\R{/*empty*/}$ )                 $\C{// for ( ; true; )}$
    1099 do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$
     1098while ( ®/*empty*/®  )                  $\C{// while ( true )}$
     1099for ( ®/*empty*/® )                    $\C{// for ( ; true; )}$
     1100do ... while ( ®/*empty*/®  )    $\C{// do ... while ( true )}$
    11001101\end{cfa}
    11011102\item
    11021103A comparison N is implicit up-to exclusive range [0,N\R{)}.
    11031104\begin{cfa}
    1104 for ( @5@ )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
     1105for ( ®5® )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
    11051106\end{cfa}
    11061107\item
    11071108A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.
    11081109\begin{cfa}
    1109 for ( @=@5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
     1110for ( ®=®5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
    11101111\end{cfa}
    11111112\item
    11121113The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}.
    11131114\begin{cfa}
    1114 for ( 1@~@5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
     1115for ( 1®~®5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
    11151116\end{cfa}
    11161117\item
    11171118The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}.
    11181119\begin{cfa}
    1119 for ( 1@~=@5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
     1120for ( 1®~=®5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
    11201121\end{cfa}
    11211122\item
    11221123The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M\R{)}.
    11231124\begin{cfa}
    1124 for ( 1@-~@5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
     1125for ( 1®-~®5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
    11251126\end{cfa}
    11261127\item
    11271128The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M\R{]}.
    11281129\begin{cfa}
    1129 for ( 1@-~=@5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
     1130for ( 1®-~=®5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
    11301131\end{cfa}
    11311132\item
    11321133©@© means put nothing in this field.
    11331134\begin{cfa}
    1134 for ( 1~$\R{@}$~2 )                             $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
     1135for ( 1~®@®~2 )                                 $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
    11351136\end{cfa}
    11361137\item
    11371138©:© means start another index.
    11381139\begin{cfa}
    1139 for ( i; 5 @:@ j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
     1140for ( i; 5 ®:® j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
    11401141\end{cfa}
    11411142\end{itemize}
    11421143
    11431144
    1144 %\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
     1145%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
    11451146\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
    11461147
    … …  
    11571158\begin{lrbox}{\myboxA}
    11581159\begin{cfa}[tabsize=3]
    1159 @Compound:@ {
    1160         @Try:@ try {
    1161                 @For:@ for ( ... ) {
    1162                         @While:@ while ( ... ) {
    1163                                 @Do:@ do {
    1164                                         @If:@ if ( ... ) {
    1165                                                 @Switch:@ switch ( ... ) {
     1160®Compound:® {
     1161        ®Try:® try {
     1162                ®For:® for ( ... ) {
     1163                        ®While:® while ( ... ) {
     1164                                ®Do:® do {
     1165                                        ®If:® if ( ... ) {
     1166                                                ®Switch:® switch ( ... ) {
    11661167                                                        case 3:
    1167                                                                 @break Compound@;
    1168                                                                 @break Try@;
    1169                                                                 @break For@;      /* or */  @continue For@;
    1170                                                                 @break While@;  /* or */  @continue While@;
    1171                                                                 @break Do@;      /* or */  @continue Do@;
    1172                                                                 @break If@;
    1173                                                                 @break Switch@;
     1168                                                                ®break Compound®;
     1169                                                                ®break Try®;
     1170                                                                ®break For®;      /* or */  ®continue For®;
     1171                                                                ®break While®;  /* or */  ®continue While®;
     1172                                                                ®break Do®;      /* or */  ®continue Do®;
     1173                                                                ®break If®;
     1174                                                                ®break Switch®;
    11741175                                                        } // switch
    11751176                                                } else {
    1176                                                         ... @break If@; ...     // terminate if
     1177                                                        ... ®break If®; ...     // terminate if
    11771178                                                } // if
    11781179                                } while ( ... ); // do
    11791180                        } // while
    11801181                } // for
    1181         } @finally@ { // always executed
     1182        } ®finally® { // always executed
    11821183        } // try
    11831184} // compound
    … …  
    11891190{
    11901191
    1191                 @ForC:@ for ( ... ) {
    1192                         @WhileC:@ while ( ... ) {
    1193                                 @DoC:@ do {
     1192                ®ForC:® for ( ... ) {
     1193                        ®WhileC:® while ( ... ) {
     1194                                ®DoC:® do {
    11941195                                        if ( ... ) {
    11951196                                                switch ( ... ) {
    11961197                                                        case 3:
    1197                                                                 @goto Compound@;
    1198                                                                 @goto Try@;
    1199                                                                 @goto ForB@;      /* or */  @goto ForC@;
    1200                                                                 @goto WhileB@;  /* or */  @goto WhileC@;
    1201                                                                 @goto DoB@;      /* or */  @goto DoC@;
    1202                                                                 @goto If@;
    1203                                                                 @goto Switch@;
    1204                                                         } @Switch:@ ;
     1198                                                                ®goto Compound®;
     1199                                                                ®goto Try®;
     1200                                                                ®goto ForB®;      /* or */  ®goto ForC®;
     1201                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
     1202                                                                ®goto DoB®;      /* or */  ®goto DoC®;
     1203                                                                ®goto If®;
     1204                                                                ®goto Switch®;
     1205                                                        } ®Switch:® ;
    12051206                                                } else {
    1206                                                         ... @goto If@; ...      // terminate if
    1207                                                 } @If:@;
    1208                                 } while ( ... ); @DoB:@ ;
    1209                         } @WhileB:@ ;
    1210                 } @ForB:@ ;
    1211 
    1212 
    1213 } @Compound:@ ;
     1207                                                        ... ®goto If®; ...      // terminate if
     1208                                                } ®If:®;
     1209                                } while ( ... ); ®DoB:® ;
     1210                        } ®WhileB:® ;
     1211                } ®ForB:® ;
     1212
     1213
     1214} ®Compound:® ;
    12141215\end{cfa}
    12151216\end{lrbox}
    … …  
    12401241
    12411242
    1242 %\subsection{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
     1243%\subsection{\texorpdfstring{\protect\lstinline{with} Statement}{with Statement}}
    12431244\subsection{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
    12441245\label{s:WithStatement}
    … …  
    12551256\begin{cfa}
    12561257Person p
    1257 @p.@name; @p.@address; @p.@sex; $\C{// access containing fields}$
     1258®p.®name; ®p.®address; ®p.®sex; $\C{// access containing fields}$
    12581259\end{cfa}
    12591260which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
    12601261\begin{cfa}
    12611262struct Ticket { ... } t;
    1262 @p.name@.first; @p.address@.street;             $\C{// access nested fields}$
    1263 @t.@departure; @t.@cost;                                $\C{// access multiple aggregate}$
     1263®p.name®.first; ®p.address®.street;             $\C{// access nested fields}$
     1264®t.®departure; ®t.®cost;                                $\C{// access multiple aggregate}$
    12641265\end{cfa}
    12651266Repeated aggregate qualification is tedious and makes code difficult to read.
    … …  
    12841285\begin{C++}
    12851286struct S {
    1286         char @c@;   int @i@;   double @d@;
     1287        char ®c®;   int ®i®;   double ®d®;
    12871288        void f( /* S * this */ ) {                              $\C{// implicit ``this'' parameter}$
    1288                 @c@;   @i@;   @d@;                                      $\C{// this->c; this->i; this->d;}$
     1289                ®c®;   ®i®;   ®d®;                                      $\C{// this->c; this->i; this->d;}$
    12891290        }
    12901291}
    … …  
    12941295\begin{cfa}
    12951296struct T {
    1296         char @m@;   int @i@;   double @n@;              $\C{// derived class variables}$
     1297        char ®m®;   int ®i®;   double ®n®;              $\C{// derived class variables}$
    12971298};
    12981299struct S : public T {
    1299         char @c@;   int @i@;   double @d@;              $\C{// class variables}$
    1300         void g( double @d@, T & t ) {
    1301                 d;   @t@.m;   @t@.i;   @t@.n;           $\C{// function parameter}$
    1302                 c;   i;   @this->@d;   @S::@d;          $\C{// class S variables}$
    1303                 m;   @T::@i;   n;                                       $\C{// class T variables}$
     1300        char ®c®;   int ®i®;   double ®d®;              $\C{// class variables}$
     1301        void g( double ®d®, T & t ) {
     1302                d;   ®t®.m;   ®t®.i;   ®t®.n;           $\C{// function parameter}$
     1303                c;   i;   ®this->®d;   ®S::®d;          $\C{// class S variables}$
     1304                m;   ®T::®i;   n;                                       $\C{// class T variables}$
    13041305        }
    13051306};
    … …  
    13111312Hence, the qualified fields become variables with the side-effect that it is simpler to write, easier to read, and optimize field references in a block.
    13121313\begin{cfa}
    1313 void f( S & this ) @with ( this )@ {            $\C{// with statement}$
    1314         @c@;   @i@;   @d@;                                              $\C{// this.c, this.i, this.d}$
     1314void f( S & this ) ®with ( this )® {            $\C{// with statement}$
     1315        ®c®;   ®i®;   ®d®;                                              $\C{// this.c, this.i, this.d}$
    13151316}
    13161317\end{cfa}
    13171318with the generality of opening multiple aggregate-parameters:
    13181319\begin{cfa}
    1319 void g( S & s, T & t ) @with ( s, t )@ {        $\C{// multiple aggregate parameters}$
    1320         c;   @s.@i;   d;                                                $\C{// s.c, s.i, s.d}$
    1321         m;   @t.@i;   n;                                                $\C{// t.m, t.i, t.n}$
     1320void g( S & s, T & t ) ®with ( s, t )® {        $\C{// multiple aggregate parameters}$
     1321        c;   ®s.®i;   d;                                                $\C{// s.c, s.i, s.d}$
     1322        m;   ®t.®i;   n;                                                $\C{// t.m, t.i, t.n}$
    13221323}
    13231324\end{cfa}
    … …  
    13381339The difference between parallel and nesting occurs for fields with the same name and type:
    13391340\begin{cfa}
    1340 struct Q { int @i@; int k; int @m@; } q, w;
    1341 struct R { int @i@; int j; double @m@; } r, w;
     1341struct Q { int ®i®; int k; int ®m®; } q, w;
     1342struct R { int ®i®; int j; double ®m®; } r, w;
    13421343with ( r, q ) {
    13431344        j + k;                                                                  $\C{// unambiguous, r.j + q.k}$
    … …  
    13721373\begin{cfa}
    13731374void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$
    1374         @s.i = i;@  j = 3;  m = 5.5; $\C{// initialize fields}$
     1375        ®s.i = i;®  j = 3;  m = 5.5; $\C{// initialize fields}$
    13751376}
    13761377\end{cfa}
    … …  
    13851386and implicitly opened \emph{after} a function-body open, to give them higher priority:
    13861387\begin{cfa}
    1387 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { // syntax not allowed, illustration only
    1388         s.i = @i@; j = 3; m = 5.5;
     1388void ?{}( S & s, int ®i® ) with ( s ) ®with( $\emph{\R{params}}$ )® { // syntax not allowed, illustration only
     1389        s.i = ®i®; j = 3; m = 5.5;
    13891390}
    13901391\end{cfa}
    … …  
    14691470For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
    14701471\begin{cfa}
    1471 int @(*@f@())[@5@]@ {...}; $\C{// definition}$
    1472  ... @(*@f@())[@3@]@ += 1; $\C{// usage}$
     1472int ®(*®f®())[®5®]® {...}; $\C{// definition}$
     1473 ... ®(*®f®())[®3®]® += 1; $\C{// usage}$
    14731474\end{cfa}
    14741475Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
    … …  
    14861487\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    14871488\begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
    1488 #[5] *# @int@ x1;
    1489 #* [5]# @int@ x2;
    1490 #[* [5] int]# f@( int p )@;
     1489#[5] *# ®int® x1;
     1490#* [5]# ®int® x2;
     1491#[* [5] int]# f®( int p )®;
    14911492\end{cfa}
    14921493&
    14931494\begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
    1494 @int@ #*# x1 #[5]#;
    1495 @int@ #(*#x2#)[5]#;
    1496 #int (*#f@( int p )@#)[5]#;
     1495®int® #*# x1 #[5]#;
     1496®int® #(*#x2#)[5]#;
     1497#int (*#f®( int p )®#)[5]#;
    14971498\end{cfa}
    14981499\end{tabular}
    … …  
    15061507\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    15071508\begin{cfa}
    1508 @*@ int x, y;
     1509®*® int x, y;
    15091510\end{cfa}
    15101511&
    15111512\begin{cfa}
    1512 int @*@x, @*@y;
     1513int ®*®x, ®*®y;
    15131514\end{cfa}
    15141515\end{tabular}
    … …  
    15191520\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    15201521\begin{cfa}
    1521 @*@ int x;
     1522®*® int x;
    15221523int y;
    15231524\end{cfa}
    15241525&
    15251526\begin{cfa}
    1526 int @*@x, y;
     1527int ®*®x, y;
    15271528
    15281529\end{cfa}
    … …  
    16601661&
    16611662\begin{cfa}
    1662 int * @const@ x = (int *)100
     1663int * ®const® x = (int *)100
    16631664*x = 3;                 // implicit dereference
    1664 int * @const@ y = (int *)104;
     1665int * ®const® y = (int *)104;
    16651666*y = *x;                        // implicit dereference
    16661667\end{cfa}
    … …  
    17001701\begin{tabular}{@{}l@{\hspace{2em}}l@{}}
    17011702\begin{cfa}
    1702 int x, y, @*@ p1, @*@ p2, @**@ p3;
    1703 p1 = @&@x;     // p1 points to x
     1703int x, y, ®*® p1, ®*® p2, ®**® p3;
     1704p1 = ®&®x;     // p1 points to x
    17041705p2 = p1;     // p2 points to x
    1705 p1 = @&@y;     // p1 points to y
     1706p1 = ®&®y;     // p1 points to y
    17061707p3 = &p2;  // p3 points to p2
    17071708\end{cfa}
    … …  
    17291730\begin{cfa}
    17301731p1 = p2; $\C{// pointer address assignment}$
    1731 @*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$
     1732®*®p2 = ®*®p1 + x; $\C{// pointed-to value assignment / operation}$
    17321733\end{cfa}
    17331734The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
    … …  
    17451746To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s).
    17461747\begin{cfa}
    1747 int x, y, @&@ r1, @&@ r2, @&&@ r3;
    1748 @&@r1 = &x; $\C{// r1 points to x}$
    1749 @&@r2 = &r1; $\C{// r2 points to x}$
    1750 @&@r1 = &y; $\C{// r1 points to y}$
    1751 @&&@r3 = @&@&r2; $\C{// r3 points to r2}$
     1748int x, y, ®&® r1, ®&® r2, ®&&® r3;
     1749®&®r1 = &x; $\C{// r1 points to x}$
     1750®&®r2 = &r1; $\C{// r2 points to x}$
     1751®&®r1 = &y; $\C{// r1 points to y}$
     1752®&&®r3 = ®&®&r2; $\C{// r3 points to r2}$
    17521753r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
    17531754\end{cfa}
    … …  
    17561757One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in a declaration, so the previous example becomes:
    17571758\begin{cfa}
    1758 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);
     1759®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
    17591760\end{cfa}
    17601761When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
    … …  
    17651766For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
    17661767\begin{cfa}
    1767 (&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
     1768(&®*®)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
    17681769\end{cfa}
    17691770Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
    17701771\begin{cfa}
    1771 (&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
     1772(&(&®*®)®*®)r3 = &(&®*®)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
    17721773\end{cfa}
    17731774Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
    … …  
    17921793const int cx = 5; $\C{// cannot change cx;}$
    17931794const int & cr = cx; $\C{// cannot change what cr points to}$
    1794 @&@cr = &cx; $\C{// can change cr}$
     1795®&®cr = &cx; $\C{// can change cr}$
    17951796cr = 7; $\C{// error, cannot change cx}$
    17961797int & const rc = x; $\C{// must be initialized}$
    1797 @&@rc = &x; $\C{// error, cannot change rc}$
     1798®&®rc = &x; $\C{// error, cannot change rc}$
    17981799const int & const crc = cx; $\C{// must be initialized}$
    17991800crc = 7; $\C{// error, cannot change cx}$
    1800 @&@crc = &cx; $\C{// error, cannot change crc}$
     1801®&®crc = &cx; $\C{// error, cannot change crc}$
    18011802\end{cfa}
    18021803Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
    … …  
    18191820\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    18201821\begin{cfa}
    1821 @const@ * @const@ * const int ccp;
    1822 @const@ & @const@ & const int ccr;
     1822®const® * ®const® * const int ccp;
     1823®const® & ®const® & const int ccr;
    18231824\end{cfa}
    18241825&
    18251826\begin{cfa}
    1826 const int * @const@ * @const@ ccp;
     1827const int * ®const® * ®const® ccp;
    18271828
    18281829\end{cfa}
    … …  
    18561857\begin{cfa}
    18571858int * p = &x; $\C{// assign address of x}$
    1858 @int * p = x;@ $\C{// assign value of x}$
     1859®int * p = x;® $\C{// assign value of x}$
    18591860int & r = x; $\C{// must have address of x}$
    18601861\end{cfa}
    … …  
    18801881When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
    18811882\begin{cfa}
    1882 void f( @const@ int & cr );
    1883 void g( @const@ int * cp );
    1884 f( 3 );                   g( @&@3 );
    1885 f( x + y );             g( @&@(x + y) );
     1883void f( ®const® int & cr );
     1884void g( ®const® int * cp );
     1885f( 3 );                   g( ®&®3 );
     1886f( x + y );             g( ®&®(x + y) );
    18861887\end{cfa}
    18871888Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter.
    … …  
    18941895void f( int & r );
    18951896void g( int * p );
    1896 f( 3 );                   g( @&@3 ); $\C{// compiler implicit generates temporaries}$
    1897 f( x + y );             g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$
     1897f( 3 );                   g( ®&®3 ); $\C{// compiler implicit generates temporaries}$
     1898f( x + y );             g( ®&®(x + y) ); $\C{// compiler implicit generates temporaries}$
    18981899\end{cfa}
    18991900Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
    … …  
    19161917Instead, a routine object should be referenced by a ©const© reference:
    19171918\begin{cfa}
    1918 @const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$
     1919®const® void (®&® fr)( int ) = f; $\C{// routine reference}$
    19191920fr = ... $\C{// error, cannot change code}$
    19201921&fr = ...; $\C{// changing routine reference}$
    … …  
    19781979\begin{cfa}
    19791980int x, &r = x, f( int p );
    1980 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$
     1981x = ®r® + f( ®r® ); $\C{// lvalue reference converts to rvalue}$
    19811982\end{cfa}
    19821983An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
    19831984
    19841985\item
    1985 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
    1986 \begin{cfa}
    1987 int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
    1988 f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$
     1986lvalue to reference conversion: \lstinline[deletekeywords=lvalue]{lvalue-type cv1 T} converts to ©cv2 T &©, which allows implicitly converting variables to references.
     1987\begin{cfa}
     1988int x, &r = ®x®, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
     1989f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}$
    19891990\end{cfa}
    19901991Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
    … …  
    19961997\begin{cfa}
    19971998int x, & f( int & p );
    1998 f( @x + 3@ );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
    1999 @&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
     1999f( ®x + 3® );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
     2000®&f®(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
    20002001\end{cfa}
    20012002In both case, modifications to the temporary are inaccessible (\Index{warning}).
    … …  
    21642165
    21652166
     2167\section{Enumeration}
     2168
     2169An \newterm{enumeration} is a compile-time mechanism to alias names to constants, like ©typedef© is a mechanism to alias names to types.
     2170Its purpose is to define a restricted-value type providing code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
     2171
     2172An enumeration type is a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) aliased to a fixed value (constant).
     2173\begin{cfa}
     2174enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names & values
     2175Days days = Mon; // enumeration type declaration and initialization
     2176\end{cfa}
     2177The set of enums are injected into the variable namespace at the definition scope.
     2178Hence, enums may be overloaded with enum/variable/function names.
     2179\begin{cfa}
     2180enum Foo { Bar };
     2181enum Goo { Bar };       $\C[1.75in]{// overload Foo.Bar}$
     2182int Foo;                        $\C{// type/variable separate namespace}$
     2183double Bar;                     $\C{// overload Foo.Bar, Goo.Bar}\CRT$
     2184\end{cfa}
     2185An anonymous enumeration injects enums with specific values into a scope.
     2186\begin{cfa}
     2187enum { Prime = 103, BufferSize = 1024 };
     2188\end{cfa}
     2189An enumeration is better than using C \Index{preprocessor} or constant declarations.
     2190\begin{cquote}
     2191\begin{tabular}{@{}l@{\hspace{4em}}l@{}}
     2192\begin{cfa}
     2193#define Mon 0
     2194...
     2195#define Sun 6
     2196\end{cfa}
     2197&
     2198\begin{cfa}
     2199const int Mon = 0,
     2200                         ...,
     2201                         Sun = 6;
     2202\end{cfa}
     2203\end{tabular}
     2204\end{cquote}
     2205because the enumeration is succinct, has automatic numbering, can appear in ©case© labels, does not use storage, and is part of the language type-system.
     2206Finally, the type of an enum is implicitly or explicitly specified and the constant value can be implicitly or explicitly specified.
     2207Note, enum values may be repeated in an enumeration.
     2208
     2209
     2210\subsection{Enum type}
     2211
     2212The type of enums can be any type, and an enum's value comes from this type.
     2213Because an enum is a constant, it cannot appear in a mutable context, \eg ©Mon = Sun© is disallowed, and has no address (it is an rvalue).
     2214Therefore, an enum is automatically converted to its constant's base-type, \eg comparing/printing an enum compares/prints its value rather than the enum name;
     2215there is no mechanism to print the enum name.
     2216
     2217The default enum type is ©int©.
     2218Hence, ©Days© is the set type ©Mon©, ©Tue©, ...\,, ©Sun©, while the type of each enum is ©int© and each enum represents a fixed integral value.
     2219If no values are specified for an integral enum type, the enums are automatically numbered by one from left to right starting at zero.
     2220Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
     2221If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
     2222If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
     2223
     2224\CFA allows other integral types with associated values.
     2225\begin{cfa}
     2226enum( ®char® ) Letter { A ®= 'A'®,  B,  C,  I ®= 'I'®,  J,  K };
     2227enum( ®long long int® ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
     2228\end{cfa}
     2229For enumeration ©Letter©, enum ©A©'s value is explicitly set to ©'A'©, with ©B© and ©C© implicitly numbered with increasing values from ©'A'©, and similarly for enums ©I©, ©J©, and ©K©.
     2230
     2231Non-integral enum types must be explicitly initialized, \eg ©double© is not automatically numbered by one.
     2232\begin{cfa}
     2233// non-integral numeric
     2234enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
     2235// pointer
     2236enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
     2237int i, j, k;
     2238enum( ®int *® ) ptr { I = &i,  J = &j,  K = &k };
     2239enum( ®int &® ) ref { I = i,  J = j,  K = k };
     2240// tuple
     2241enum( ®[int, int]® ) { T = [ 1, 2 ] };
     2242// function
     2243void f() {...}   void g() {...}
     2244enum( ®void (*)()® ) funs { F = f,  F = g };
     2245// aggregate
     2246struct S { int i, j; };
     2247enum( ®S® ) s { A = { 3,  4 }, B = { 7,  8 } };
     2248// enumeration
     2249enum( ®Letter® ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
     2250\end{cfa}
     2251Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
     2252Therefore, ©Greek© enums are a subset of type ©Letter© and are type compatible with enumeration ©Letter©, but ©Letter© enums are not type compatible with enumeration ©Greek©.
     2253
     2254The following examples illustrate the difference between the enumeration type and the type of its enums.
     2255\begin{cfa}
     2256Math m = PI;    $\C[1.5in]{// allowed}$
     2257double d = PI;  $\C{// allowed, conversion to base type}$
     2258m = E;                  $\C{// allowed}$
     2259m = Alph;               $\C{// {\color{red}disallowed}}$
     2260m = 3.141597;   $\C{// {\color{red}disallowed}}$
     2261d = m;                  $\C{// allowed}$
     2262d = Alph;               $\C{// {\color{red}disallowed}}$
     2263Letter l = A;   $\C{// allowed}$
     2264Greek g = Alph; $\C{// allowed}$
     2265l = Alph;               $\C{// allowed, conversion to base type}$
     2266g = A;                  $\C{// {\color{red}disallowed}}\CRT$
     2267\end{cfa}
     2268
     2269A constructor \emph{cannot} be used to initialize enums because a constructor executes at runtime.
     2270A fallback is explicit C-style initialization using ©@=©.
     2271\begin{cfa}
     2272enum( struct vec3 ) Axis { Up @= { 1, 0, 0 }, Left @= { 0, 1, 0 }, Front @= { 0, 0, 1 } }
     2273\end{cfa}
     2274Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
     2275
     2276
     2277\subsection{Inheritance}
     2278
     2279\Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
     2280\begin{cfa}
     2281enum( char * ) Name2 { ®inline Name®, Jack = "Jack", Jill = "Jill" };
     2282enum ®/* inferred */®  Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
     2283\end{cfa}
     2284Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
     2285Note, enums must be unique in inheritance but enum values may be repeated.
     2286The enum type for the inheriting type must be the same as the inherited type;
     2287hence the enum type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for ©Name3©.
     2288When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important, \eg the placement of ©Sue© and ©Tom© before or after ©inline Name2©.
     2289
     2290Specifically, the inheritance relationship for ©Name©s is:
     2291\begin{cfa}
     2292Name $\(\subseteq\)$ Name2 $\(\subseteq\)$ Name3 $\(\subseteq\)$ const char * // enum type of Name
     2293\end{cfa}
     2294Hence, given
     2295\begin{cfa}
     2296void f( Name );
     2297void g( Name2 );
     2298void h( Name3 );
     2299void j( const char * );
     2300\end{cfa}
     2301the following calls are valid
     2302\begin{cfa}
     2303f( Fred );
     2304g( Fred );   g( Jill );
     2305h( Fred );   h( Jill );   h( Sue );
     2306j( Fred );    j( Jill );    j( Sue );    j( 'W' );
     2307\end{cfa}
     2308Note, the validity of calls is the same for call-by-reference as for call-by-value, and ©const© restrictions are the same as for other types.
     2309
     2310Enums cannot be created at runtime, so inheritence problems, such as contra-variance do not apply.
     2311Only instances of the enum base-type may be created at runtime.
     2312
     2313\begin{comment}
     2314The invariance of references, as I show at the bottom, is easy to overlook.  Not shown, but on the same topic, is that returns work in the opposite direction as parameters.  Hopefully our existing type rules already know both those facts, so that we'd only have to provide the rules that I suggest using the by-value parameters.
     2315
     2316The Fred, Jack, and Mary declarations are picked verbatim from our earlier whiteboard, just repeated here for reference.
     2317
     2318\begin{cfa}
     2319// Fred is a subset of char *
     2320enum( char *) Fred { A = "A", B = "B", C = "C" };
     2321// Jack is a subset of Fred
     2322enum( enum Fred ) Jack { W = A, Y = C};
     2323// Mary is a superset of Fred
     2324enum Mary { inline Fred, D = "hello" };
     2325
     2326// Demonstrating invariance of references
     2327
     2328[void] frcs( & * char x ) { char * x0 = x; x = "bye"; }
     2329[void] frf ( & Fred   x ) { Fred   x0 = x; x = B;     }
     2330[void] frj ( & Jack   x ) { Jack   x0 = x; x = W;     }
     2331[void] frm ( & Mary   x ) { Mary   x0 = x; x = D;     }
     2332
     2333char * vcs;
     2334Fred   vf;
     2335Jack   vj;
     2336Mary   vm;
     2337
     2338// all variant calls: bad  (here are noteworthy examples)
     2339             frcs( vf  );  // can't assign "bye" to vf
     2340             frm ( vf  );  // can't assign D     to vf
     2341             frf ( vj  );  // can't assign B     to vj
     2342vf  = B    ; frj ( vf  );  // can't assign B     to frj.x0
     2343vcs = "bye"; frf ( vcs );  // can't assign "bye" to frf.x0
     2344\end{cfa}
     2345
     2346This example is really great. However, I think it's work explicitly doing one with ©const &©.
     2347\end{comment}
     2348
     2349
    21662350\section{Routine Definition}
    21672351
    2168 \CFA also supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
     2352\CFA supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
    21692353The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
    21702354\begin{cfa}
    2171 @[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) {
     2355®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
    21722356        $\emph{routine body}$
    21732357}
    21742358\end{cfa}
    21752359where routine ©f© has three output (return values) and three input parameters.
    2176 Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type specifications.
     2360Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type-specifications.
    21772361
    21782362In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
    … …  
    21812365Declaration qualifiers can only appear at the start of a routine definition, \eg:
    21822366\begin{cfa}
    2183 @extern@ [ int x ] g( int y ) {$\,$}
     2367®extern® [ int x ] g( int y ) {$\,$}
    21842368\end{cfa}
    21852369Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
    … …  
    22002384int (*f(x))[ 5 ] int x; {}
    22012385\end{cfa}
    2202 The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter x of type array of 5 integers.
     2386The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter ©x© of type array of 5 integers.
    22032387Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
    22042388As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
    … …  
    22392423\begin{minipage}{\linewidth}
    22402424\begin{cfa}
    2241 @[ int x, int y ]@ f() {
     2425®[ int x, int y ]® f() {
    22422426        int z;
    22432427        ... x = 0; ... y = z; ...
    2244         @return;@ $\C{// implicitly return x, y}$
     2428        ®return;® $\C{// implicitly return x, y}$
    22452429}
    22462430\end{cfa}
    … …  
    25742758
    25752759int fred() {
    2576         s.t.c = @S.@R;  // type qualification
    2577         struct @S.@T t = { @S.@R, 1, 2 };
    2578         enum @S.@C c;
    2579         union @S.T.@U u;
     2760        s.t.c = ®S.®R;  // type qualification
     2761        struct ®S.®T t = { ®S.®R, 1, 2 };
     2762        enum ®S.®C c;
     2763        union ®S.T.®U u;
    25802764}
    25812765\end{cfa}
    … …  
    26032787qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
    26042788{
    2605         @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$
     2789        ®int ?<?( int x, int y ) { return x > y; }® $\C{// nested routine}$
    26062790        qsort( ia, size ); $\C{// sort descending order by local redefinition}$
    26072791}
    … …  
    26132797\begin{cfa}
    26142798[* [int]( int )] foo() { $\C{// int (* foo())( int )}$
    2615         int @i@ = 7;
     2799        int ®i® = 7;
    26162800        int bar( int p ) {
    2617                 @i@ += 1; $\C{// dependent on local variable}$
    2618                 sout | @i@;
     2801                ®i® += 1; $\C{// dependent on local variable}$
     2802                sout | ®i®;
    26192803        }
    26202804        return bar; $\C{// undefined because of local dependence}$
    … …  
    26342818In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
    26352819\begin{cfa}
    2636 f( @2, x, 3 + i@ ); $\C{// element list}$
     2820f( ®2, x, 3 + i® ); $\C{// element list}$
    26372821\end{cfa}
    26382822A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
    … …  
    27472931In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
    27482932\begin{cfa}
    2749 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$
    2750 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$
     2933[int, int] ®qr® = div( 13, 5 ); $\C{// initialize tuple variable}$
     2934printf( "%d %d\n", ®qr® ); $\C{// print quotient/remainder}$
    27512935\end{cfa}
    27522936It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
    … …  
    34123596\begin{cfa}
    34133597int x = 1, y = 2, z = 3;
    3414 sout | x @|@ y @|@ z;
     3598sout | x ®|® y ®|® z;
    34153599\end{cfa}
    34163600&
    34173601\begin{cfa}
    34183602
    3419 cout << x @<< " "@ << y @<< " "@ << z << endl;
     3603cout << x ®<< " "® << y ®<< " "® << z << endl;
    34203604\end{cfa}
    34213605&
    … …  
    34263610\\
    34273611\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3428 1@ @2@ @3
     36121® ®2® ®3
    34293613\end{cfa}
    34303614&
    34313615\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3432 1@ @2@ @3
     36161® ®2® ®3
    34333617\end{cfa}
    34343618&
    34353619\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3436 1@ @2@ @3
     36201® ®2® ®3
    34373621\end{cfa}
    34383622\end{tabular}
    34393623\end{cquote}
    34403624The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators and newline.
    3441 Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]@, @''.
     3625Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]{, }''.
    34423626\begin{cfa}
    34433627[int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
    … …  
    34453629\end{cfa}
    34463630\begin{cfa}[showspaces=true,aboveskip=0pt]
    3447 1@, @2@, @3 4@, @5@, @6
     36311®, ®2®, ®3 4®, ®5®, ®6
    34483632\end{cfa}
    34493633Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
    … …  
    34543638&
    34553639\begin{cfa}
    3456 sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;
     3640sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
    34573641\end{cfa}
    34583642\\
    … …  
    34603644&
    34613645\begin{cfa}
    3462 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@ << endl;
     3646cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
    34633647\end{cfa}
    34643648\\
    … …  
    34953679\\
    34963680\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3497 @1@ @2.5@ @A@
     3681®1® ®2.5® ®A®
    34983682
    34993683
    … …  
    35013685&
    35023686\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3503 @1@ @2.5@ @A@
     3687®1® ®2.5® ®A®
    35043688
    35053689
    … …  
    35073691&
    35083692\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3509 @1@
    3510 @2.5@
    3511 @A@
     3693®1®
     3694®2.5®
     3695®A®
    35123696\end{cfa}
    35133697\end{tabular}
    … …  
    35453729
    35463730\item
    3547 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} a closing citation mark.
     3731A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} is a closing citation mark.
    35483732\begin{cfa}
    35493733sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
    … …  
    35513735\end{cfa}
    35523736\begin{cfa}[showspaces=true]
    3553 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
     37371®,® 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
    35543738\end{cfa}
    35553739
    … …  
    35583742%$
    35593743\begin{cfa}
    3560 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
     3744sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
    35613745           | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
    35623746\end{cfa}
    35633747%$
    35643748\begin{cfa}[showspaces=true]
    3565 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
     3749x ®(®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
    35663750\end{cfa}
    35673751%$
    35683752
    35693753\item
    3570 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
     3754A separator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
    35713755\begin{cfa}
    35723756sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
    35733757\end{cfa}
    35743758\begin{cfa}[showspaces=true,showtabs=true]
    3575 x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@  @6@     @x
     3759x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
    35763760\end{cfa}
    35773761
    … …  
    35823766\end{cfa}
    35833767\begin{cfa}[showspaces=true,showtabs=true]
    3584 x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4
     3768x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
    35853769\end{cfa}
    35863770\end{enumerate}
    … …  
    35953779\Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
    35963780The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    3597 \begin{cfa}[escapechar=off,belowskip=0pt]
    3598 sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$
    3599 sout | 1 | 2 | 3 | " \"" | @sep@ | "\"";
    3600 \end{cfa}
    3601 %$
    3602 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
    3603 1@, $@2@, $@3 @", $"@
    3604 \end{cfa}
    3605 %$
     3781\begin{cfa}[belowskip=0pt]
     3782sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
     3783sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
     3784\end{cfa}
     3785\begin{cfa}[showspaces=true,aboveskip=0pt]
     37861®, $\LstStringStyle{\textdollar}$®2®, $\LstStringStyle{\textdollar}$®3 ®", $\LstStringStyle{\textdollar}$"®
     3787\end{cfa}
    36063788\begin{cfa}[belowskip=0pt]
    36073789sepSet( sout, " " ); $\C{// reset separator to " "}$
    3608 sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@ | "\"";
     3790sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
    36093791\end{cfa}
    36103792\begin{cfa}[showspaces=true,aboveskip=0pt]
    3611 1@ @2@ @3 @" "@
     37931® ®2® ®3 ®" "®
    36123794\end{cfa}
    36133795©sepGet© can be used to store a separator and then restore it:
    36143796\begin{cfa}[belowskip=0pt]
    3615 char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$
     3797char store[®sepSize®]; $\C{// sepSize is the maximum separator size}$
    36163798strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
    36173799sepSet( sout, "_" ); $\C{// change separator to underscore}$
    … …  
    36193801\end{cfa}
    36203802\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3621 1@_@2@_@3
     38031®_®2®_®3
    36223804\end{cfa}
    36233805\begin{cfa}[belowskip=0pt]
    … …  
    36263808\end{cfa}
    36273809\begin{cfa}[showspaces=true,aboveskip=0pt]
    3628 1@ @2@ @3
     38101® ®2® ®3
    36293811\end{cfa}
    36303812
    … …  
    36343816\begin{cfa}[belowskip=0pt]
    36353817sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
    3636 sout | t1 | t2 | " \"" | @sepTuple@ | "\"";
     3818sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
    36373819\end{cfa}
    36383820\begin{cfa}[showspaces=true,aboveskip=0pt]
    3639 1 2 3 4 5 6 @" "@
     38211 2 3 4 5 6 ®" "®
    36403822\end{cfa}
    36413823\begin{cfa}[belowskip=0pt]
    36423824sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
    3643 sout | t1 | t2 | " \"" | @sepGetTuple( sout )@ | "\"";
     3825sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
    36443826\end{cfa}
    36453827\begin{cfa}[showspaces=true,aboveskip=0pt]
    3646 1, 2, 3 4, 5, 6 @", "@
     38281, 2, 3 4, 5, 6 ®", "®
    36473829\end{cfa}
    36483830As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
    … …  
    36963878\end{cfa}
    36973879\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3698 @ @1 2 3@ @
     3880® ®1 2 3® ®
    36993881\end{cfa}
    37003882\end{enumerate}
    … …  
    37163898For example, in:
    37173899\begin{cfa}
    3718 sin | i | @nl@ | j;
    3719 1 @2@
     3900sin | i | ®nl® | j;
     39011 ®2®
    372039023
    37213903\end{cfa}
    … …  
    375839400b0 0b11011 0b11011 0b11011 0b11011
    37593941sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
    3760 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101
     39420b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101
    37613943\end{cfa}
    37623944
    … …  
    37943976
    37953977\item
     3978\Indexc{eng}( floating-point )\index{manipulator!eng@©eng©} print value in engineering notation with exponent, which means the exponent is adjusted to a multiple of 3.
     3979\begin{cfa}[belowskip=0pt]
     3980sout | eng( 0.0 ) | eng( 27000.5 ) | eng( -27.5e7 );
     39810®e0® 27.0005®e3® -275®e6®
     3982\end{cfa}
     3983
     3984\item
     3985\Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
     3986©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}$.
     3987For exponent $10^{0}$, no decimal point or letter is printed.
     3988\begin{cfa}[belowskip=0pt]
     3989sout | unit(eng( 0.0 )) | unit(eng( 27000.5 )) | unit(eng( -27.5e7 ));
     39900 27.0005®K® -275®M®
     3991\end{cfa}
     3992
     3993\item
    37963994\Indexc{upcase}( bin / hex / floating-point )\index{manipulator!upcase@©upcase©} print letters in a value in upper case. Lower case is the default.
    37973995\begin{cfa}[belowskip=0pt]
    37983996sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
    3799 0@B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+4
     39970®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
    38003998\end{cfa}
    38013999
    … …  
    38134011\begin{cfa}[belowskip=0pt]
    38144012sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
    3815 0.0 @0@ 27.0 @27@ 27.5
     40130.0 ®0® 27.0 ®27® 27.5
    38164014\end{cfa}
    38174015
    … …  
    38204018\begin{cfa}[belowskip=0pt]
    38214019sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
    3822 @+@27 -27 @+@27.0 -27.0 @+@27.5 -27.5
    3823 \end{cfa}
    3824 
    3825 \item
    3826 \Indexc{wd}©( unsigned char minimum, T val )©\index{manipulator!wd@©wd©}, ©wd( unsigned char minimum, unsigned char precision, T val )©
    3827 For all types, ©minimum© is the minimum number of printed characters.
     4020®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
     4021\end{cfa}
     4022
     4023\item
     4024\Indexc{wd}( minimum, value )\index{manipulator!wd@©wd©}, ©wd©( minimum, precision, value )
     4025For all types, minimum is the number of printed characters.
    38284026If the value is shorter than the minimum, it is padded on the right with spaces.
    38294027\begin{cfa}[belowskip=0pt]
    … …  
    38334031\end{cfa}
    38344032\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3835 @  @34 @ @34 34
    3836 @  @4.000000 @ @4.000000 4.000000
    3837 @  @ab @ @ab ab
    3838 \end{cfa}
    3839 If the value is larger, it is printed without truncation, ignoring the ©minimum©.
     4033®  ®34 ® ®34 34
     4034®  ®4.000000 ® ®4.000000 4.000000
     4035®  ®ab ® ®ab ab
     4036\end{cfa}
     4037If the value is larger, it is printed without truncation, ignoring the minimum.
    38404038\begin{cfa}[belowskip=0pt]
    38414039sout | wd( 4, 34567 ) | wd( 3, 34567 ) | wd( 2, 34567 );
    … …  
    38444042\end{cfa}
    38454043\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3846 3456@7@ 345@67@ 34@567@
    3847 3456@.@ 345@6.@ 34@56.@
    3848 abcd@e@ abc@de@ ab@cde@
    3849 \end{cfa}
    3850 
    3851 For integer types, ©precision© is the minimum number of printed digits.
     40443456®7® 345®67® 34®567®
     40453456®.® 345®6.® 34®56.®
     4046abcd®e® abc®de® ab®cde®
     4047\end{cfa}
     4048
     4049For integer types, precision is the minimum number of printed digits.
    38524050If the value is shorter, it is padded on the left with leading zeros.
    38534051\begin{cfa}[belowskip=0pt]
    … …  
    38554053\end{cfa}
    38564054\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3857  @0@34     @00@34 @00000000@34
    3858 \end{cfa}
    3859 If the value is larger, it is printed without truncation, ignoring the ©precision©.
     4055 ®0®34     ®00®34 ®00000000®34
     4056\end{cfa}
     4057If the value is larger, it is printed without truncation, ignoring the precision.
    38604058\begin{cfa}[belowskip=0pt]
    38614059sout | wd( 4,1, 3456 ) | wd( 8,2, 3456 ) | wd( 10,3, 3456 );
    … …  
    386440623456     3456       3456
    38654063\end{cfa}
    3866 If ©precision© is 0, nothing is printed for zero.
    3867 If ©precision© is greater than the minimum, it becomes the minimum.
     4064If precision is 0, nothing is printed for zero.
     4065If precision is greater than the minimum, it becomes the minimum.
    38684066\begin{cfa}[belowskip=0pt]
    38694067sout | wd( 4,0, 0 ) | wd( 3,10, 34 );
    38704068\end{cfa}
    38714069\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3872 @    @ @00000000@34
    3873 \end{cfa}
    3874 For floating-point types, ©precision© is the minimum number of digits after the decimal point.
     4070®    ® ®00000000®34
     4071\end{cfa}
     4072For floating-point types, precision is the minimum number of digits after the decimal point.
    38754073\begin{cfa}[belowskip=0pt]
    38764074sout | wd( 6,3, 27.5 ) | wd( 8,1, 27.5 ) | wd( 8,0, 27.5 ) | wd( 3,8, 27.5 );
    38774075\end{cfa}
    38784076\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3879 27.@500@     27.@5@      28. 27.@50000000@
    3880 \end{cfa}
    3881 For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
     407727.®500®     27.®5®      28. 27.®50000000®
     4078\end{cfa}
     4079For the C-string type, precision is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
    38824080\begin{cfa}[belowskip=0pt]
    38834081sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
    … …  
    38884086
    38894087\item
    3890 \Indexc{ws( unsigned char minimum, unsigned char significant, floating-point )}\index{manipulator!ws@©ws©}
    3891 For floating-point type, ©minimum© is the same as for manipulator ©wd©, but ©significant© is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
    3892 If a value's significant digits is greater than ©significant©, the last significant digit is rounded up.
     4088\begin{sloppypar}
     4089\Indexc{ws}( minimum, significant, floating-point )\index{manipulator!ws@©ws©}
     4090For floating-point types, minimum is the same as for manipulator ©wd©, but significant is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
     4091If a value's significant digits is greater than significant, the last significant digit is rounded up.
     4092\end{sloppypar}
    38934093\begin{cfa}[belowskip=0pt]
    38944094sout | ws(6,6, 234.567) | ws(6,5, 234.567) | ws(6,4, 234.567) | ws(6,3, 234.567);
    38954095\end{cfa}
    38964096\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3897 234.567 234.5@7@  234.@6@    23@5@
    3898 \end{cfa}
    3899 If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
     4097234.567 234.5®7®  234.®6®    23®5®
     4098\end{cfa}
     4099If a value's magnitude is greater than significant, the value is printed in scientific notation with the specified number of significant digits.
    39004100\begin{cfa}[belowskip=0pt]
    39014101sout | ws(6,6, 234567.) | ws(6,5, 234567.) | ws(6,4, 234567.) | ws(6,3, 234567.);
    39024102\end{cfa}
    39034103\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3904 234567. 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@
    3905 \end{cfa}
    3906 If ©significant© is greater than ©minimum©, it defines the number of printed characters.
     4104234567. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
     4105\end{cfa}
     4106If significant is greater than minimum, it defines the number of printed characters.
    39074107\begin{cfa}[belowskip=0pt]
    39084108sout | ws(3,6, 234567.) | ws(4,6, 234567.) | ws(5,6, 234567.) | ws(6,6, 234567.);
    … …  
    39184118\end{cfa}
    39194119\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3920 27@  @ 27.000000  27.500000  027  27.500@    @
     412027®  ® 27.000000  27.500000  027  27.500®    ®
    39214121\end{cfa}
    39224122
    … …  
    39254125\begin{cfa}[belowskip=0pt]
    39264126sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
    3927 @00@27  @0@27 @00@27.500
     4127®00®27  ®0®27 ®00®27.500
    39284128\end{cfa}
    39294129\end{enumerate}
    … …  
    39894189
    39904190The 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.
    3991 For ©_Bool© type, the constants are ©true© and ©false©.
     4191For ©bool© type, the constants are ©true© and ©false©.
    39924192For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
    39934193\begin{itemize}
    … …  
    40104210\begin{enumerate}
    40114211\item
    4012 \Indexc{skip( const char * pattern )}\index{manipulator!skip@©skip©} / ©skip( unsigned int length )© / ©const char * pattern©
    4013 The argument defines a ©pattern© or ©length©.
    4014 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.
    4015 The ©length© is composed of the next $N$ characters, including the newline character.
     4212\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length )
     4213The 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.
     4214The length is composed of the next $N$ characters, including the newline character.
    40164215If the match successes, the input characters are discarded, and input continues with the next character.
    40174216If the match fails, the input characters are left unread.
    … …  
    40214220\end{cfa}
    40224221\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4023 @abc   @
    4024 @abc  @
    4025 @xx@
    4026 \end{cfa}
    4027 
    4028 \item
    4029 \Indexc{wdi}©( unsigned int maximum, T & val )©\index{manipulator!wdi@©wdi©}
    4030 For all types except ©char©, ©maximum© is the maximum number of characters read for the current operation.
     4222®abc   ®
     4223®abc  ®
     4224®xx®
     4225\end{cfa}
     4226
     4227\item
     4228\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©}
     4229For all types except ©char©, maximum is the maximum number of characters read for the current operation.
    40314230\begin{cfa}[belowskip=0pt]
    40324231char s[10];   int i;   double d;   
    … …  
    40344233\end{cfa}
    40354234\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4036 @abcd1233.456E+2@
     4235®abcd1233.456E+2®
    40374236\end{cfa}
    40384237Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
    … …  
    40404239
    40414240\item
    4042 \Indexc{ignore( T & val )}\index{manipulator!ignore@©ignore©}
     4241\Indexc{ignore}( reference-value )\index{manipulator!ignore@©ignore©}
    40434242For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
    40444243\begin{cfa}[belowskip=0pt]
    … …  
    40474246\end{cfa}
    40484247\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4049 @  -75.35e-4@ 25
    4050 \end{cfa}
    4051 
    4052 \item
    4053 \Indexc{incl( const char * scanset, char * s )}\index{manipulator!incl@©incl©}
    4054 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{in} the set.
    4055 Matching characters are read into the C string and null terminated.
     4248®  -75.35e-4® 25
     4249\end{cfa}
     4250
     4251\item
     4252\Indexc{incl}( scanset, input-string )\index{manipulator!incl@©incl©}
     4253For C-string types, the scanset matches any number of characters \emph{in} the set.
     4254Matching characters are read into the C input-string and null terminated.
    40564255\begin{cfa}[belowskip=0pt]
    40574256char s[10];
    … …  
    40594258\end{cfa}
    40604259\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4061 @bca@xyz
    4062 \end{cfa}
    4063 
    4064 \item
    4065 \Indexc{excl( const char * scanset, char * s )}\index{manipulator!excl@©excl©}
    4066 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{not in} the set.
    4067 Non-matching characters are read into the C string and null terminated.
     4260®bca®xyz
     4261\end{cfa}
     4262
     4263\item
     4264\Indexc{excl}( scanset, input-string )\index{manipulator!excl@©excl©}
     4265For C-string types, the scanset matches any number of characters \emph{not in} the set.
     4266Non-matching characters are read into the C input-string and null terminated.
    40684267\begin{cfa}[belowskip=0pt]
    40694268char s[10];
    … …  
    40714270\end{cfa}
    40724271\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4073 @xyz@bca
     4272®xyz®bca
    40744273\end{cfa}
    40754274\end{enumerate}
    40764275
    40774276
     4277\subsection{Concurrent Stream Access}
     4278
     4279When a stream is shared by multiple threads, input or output characters can be intermixed or cause failure.
     4280For example, if two threads execute the following:
     4281\begin{cfa}
     4282$\emph{thread\(_1\)}$ : sout | "abc " | "def ";
     4283$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz ";
     4284\end{cfa}
     4285possible outputs are:
     4286\begin{cquote}
     4287\begin{tabular}{@{}l|l|l|l|l@{}}
     4288\begin{cfa}
     4289abc def
     4290uvw xyz
     4291\end{cfa}
     4292&
     4293\begin{cfa}
     4294abc uvw xyz
     4295def
     4296\end{cfa}
     4297&
     4298\begin{cfa}
     4299uvw abc xyz def
     4300
     4301\end{cfa}
     4302&
     4303\begin{cfa}
     4304abuvwc dexf
     4305yz
     4306\end{cfa}
     4307&
     4308\begin{cfa}
     4309uvw abc def
     4310xyz
     4311\end{cfa}
     4312\end{tabular}
     4313\end{cquote}
     4314Concurrent operations can even corrupt the internal state of the stream resulting in failure.
     4315As a result, some form of mutual exclusion is required for concurrent stream access.
     4316
     4317A coarse-grained solution is to perform all stream operations via a single thread or within a monitor providing the necessary mutual exclusion for the stream.
     4318A fine-grained solution is to have a lock for each stream, which is acquired and released around stream operations by each thread.
     4319\CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
     4320
     4321The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
     4322\begin{cfa}
     4323$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
     4324$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
     4325\end{cfa}
     4326Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
     4327\begin{cquote}
     4328\def\VRfont{\fontfamily{pcr}\upshape\selectfont}
     4329\begin{tabular}{@{}l|l@{}}
     4330\begin{cfa}
     4331abc def
     4332uvw xyz
     4333\end{cfa}
     4334&
     4335\begin{cfa}
     4336uvw xyz
     4337abc def
     4338\end{cfa}
     4339\end{tabular}
     4340\end{cquote}
     4341In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
     4342
     4343To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
     4344\begin{cfa}
     4345{       // acquire sout for block duration
     4346        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
     4347        sout | 1;
     4348        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
     4349        sout | 4;
     4350}       // implicitly release the lock when "acq" is deallocated
     4351\end{cfa}
     4352Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
     4353Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
     4354
     4355The previous values written by threads 1 and 2 can be read in concurrently:
     4356\begin{cfa}
     4357{       // acquire sin lock for block duration
     4358        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
     4359        int x, y, z, w;
     4360        sin | x;
     4361        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
     4362        sin | w;
     4363}       // implicitly release the lock when "acq" is deallocated
     4364\end{cfa}
     4365Again, the order of the reading threads is non-deterministic.
     4366Note, non-deterministic reading is rare.
     4367
     4368\Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
     4369\begin{cfa}
     4370sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
     4371\end{cfa}
     4372If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
     4373This scenario can lead to \Index{deadlock}, if the thread that is going to unblock the thread waiting in the monitor first writes to ©sout© (deadly embrace).
     4374To prevent nested locking, a simple precaution is to factor out the blocking call from the expression, \eg:
     4375\begin{cfa}
     4376int ®data® = rtn( mon );
     4377sout | acquire | "data:" | ®data®;
     4378\end{cfa}
     4379
     4380\Textbf{WARNING:} ©printf©\index{printf@©printf©}, ©scanf©\index{scanf@©scanf©} and their derivatives are unsafe when used with user-level threading, as in \CFA.
     4381These stream routines use kernel-thread locking (©futex©\index{futex@©futex©}), which block kernel threads, to prevent interleaving of I/O.
     4382However, the following simple example illustrates how a deadlock can occur (other complex scenarios are possible).
     4383Assume a single kernel thread and two user-level threads calling ©printf©.
     4384One user-level thread acquires the I/O lock and is time-sliced while performing ©printf©.
     4385The other user-level thread then starts execution, calls ©printf©, and blocks the only kernel thread because it cannot acquire the I/O lock.
     4386It does not help if the kernel lock is multiple acquisition, \ie, the lock owner can acquire it multiple times, because it then results in two user threads in the ©printf© critical section, corrupting the stream.
     4387
     4388
     4389\begin{comment}
    40784390\section{Types}
    40794391
    … …  
    41544466process((int) s); // type is converted, no function is called
    41554467\end{cfa}
     4468\end{comment}
    41564469
    41574470
    … …  
    42874600In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
    42884601However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
    4289 Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
     4602Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©bool©.
    42904603
    42914604Why just 0 and 1? Why not other integers? No other integers have special status in C.
    … …  
    43694682\begin{table}[hbt]
    43704683\centering
    4371 \input{../refrat/operidents}
     4684\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
     4685\begin{tabular}{@{}ll@{}}
     4686©?[?]©  & subscripting \impl{?[?]}                                      \\
     4687©?()©   & function call \impl{?()}                                      \\
     4688©?++©   & postfix increment \impl{?++}                          \\
     4689©?--©   & postfix decrement \impl{?--}                          \\
     4690©++?©   & prefix increment \impl{++?}                           \\
     4691©--?©   & prefix decrement \impl{--?}                           \\
     4692©*?©    & dereference \impl{*?}                                         \\
     4693©+?©    & unary plus \impl{+?}                                          \\
     4694©-?©    & arithmetic negation \impl{-?}                         \\
     4695©~?©    & bitwise negation \impl{~?}                            \\
     4696©!?©    & logical complement \impl{"!?}                         \\
     4697©?\?©   & exponentiation \impl{?\?}                                     \\
     4698©?*?©   & multiplication \impl{?*?}                                     \\
     4699©?/?©   & division \impl{?/?}                                           \\
     4700©?%?©   & remainder \impl{?%?}                                          \\
     4701\end{tabular}
     4702&
     4703\begin{tabular}{@{}ll@{}}
     4704©?+?©   & addition \impl{?+?}                                           \\
     4705©?-?©   & subtraction \impl{?-?}                                        \\
     4706©?<<?©  & left shift \impl{?<<?}                                        \\
     4707©?>>?©  & right shift \impl{?>>?}                                       \\
     4708©?<?©   & less than \impl{?<?}                                          \\
     4709©?<=?©  & less than or equal \impl{?<=?}                        \\
     4710©?>=?©  & greater than or equal \impl{?>=?}                     \\
     4711©?>?©   & greater than \impl{?>?}                                       \\
     4712©?==?©  & equality \impl{?==?}                                          \\
     4713©?!=?©  & inequality \impl{?"!=?}                                       \\
     4714©?&?©   & bitwise AND \impl{?&?}                                        \\
     4715©?^?©   & exclusive OR \impl{?^?}                                       \\
     4716©?|?©   & inclusive OR \impl{?"|?}                                      \\
     4717                                                                                                        \\
     4718                                                                                                        \\
     4719\end{tabular}
     4720&
     4721\begin{tabular}{@{}ll@{}}
     4722©?=?©   & simple assignment \impl{?=?}                          \\
     4723©?\=?©  & exponentiation assignment \impl{?\=?}         \\
     4724©?*=?©  & multiplication assignment \impl{?*=?}         \\
     4725©?/=?©  & division assignment \impl{?/=?}                       \\
     4726©?%=?©  & remainder assignment \impl{?%=?}                      \\
     4727©?+=?©  & addition assignment \impl{?+=?}                       \\
     4728©?-=?©  & subtraction assignment \impl{?-=?}            \\
     4729©?<<=?© & left-shift assignment \impl{?<<=?}            \\
     4730©?>>=?© & right-shift assignment \impl{?>>=?}           \\
     4731©?&=?©  & bitwise AND assignment \impl{?&=?}            \\
     4732©?^=?©  & exclusive OR assignment \impl{?^=?}           \\
     4733©?|=?©  & inclusive OR assignment \impl{?"|=?}          \\
     4734                                                                                                        \\
     4735                                                                                                        \\
     4736                                                                                                        \\
     4737\end{tabular}
     4738\end{tabular}
    43724739\caption{Operator Identifiers}
    43734740\label{opids}
    … …  
    44574824For example, given
    44584825\begin{cfa}
    4459 auto j = @...@
     4826auto j = ®...®
    44604827\end{cfa}
    44614828and the need to write a routine to compute using ©j©
    44624829\begin{cfa}
    4463 void rtn( @...@ parm );
     4830void rtn( ®...® parm );
    44644831rtn( j );
    44654832\end{cfa}
    … …  
    46985065\begin{figure}
    46995066\begin{cfa}
    4700 #include <fstream>
    4701 #include <coroutine>
    4702 
    4703 coroutine Fibonacci {
     5067#include <fstream.hfa>
     5068#include ®<coroutine.hfa>®
     5069
     5070®coroutine® Fibonacci {
    47045071        int fn; $\C{// used for communication}$
    47055072};
    4706 void ?{}( Fibonacci * this ) {
    4707         this->fn = 0;
    4708 }
    4709 void main( Fibonacci * this ) {
     5073
     5074void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
    47105075        int fn1, fn2; $\C{// retained between resumes}$
    4711         this->fn = 0; $\C{// case 0}$
    4712         fn1 = this->fn;
    4713         suspend(); $\C{// return to last resume}$
    4714 
    4715         this->fn = 1; $\C{// case 1}$
    4716         fn2 = fn1;
    4717         fn1 = this->fn;
    4718         suspend(); $\C{// return to last resume}$
    4719 
    4720         for ( ;; ) { $\C{// general case}$
    4721                 this->fn = fn1 + fn2;
    4722                 fn2 = fn1;
    4723                 fn1 = this->fn;
    4724                 suspend(); $\C{// return to last resume}$
    4725         } // for
    4726 }
    4727 int next( Fibonacci * this ) {
    4728         resume( this ); $\C{// transfer to last suspend}$
    4729         return this->fn;
     5076        fn = 0;  fn1 = fn; $\C{// 1st case}$
     5077        ®suspend;® $\C{// restart last resume}$
     5078        fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
     5079        ®suspend;® $\C{// restart last resume}$
     5080        for () {
     5081                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
     5082                ®suspend;® $\C{// restart last resume}$
     5083        }
     5084}
     5085int next( Fibonacci & fib ) with( fib ) {
     5086        ®resume( fib );® $\C{// restart last suspend}$
     5087        return fn;
    47305088}
    47315089int main() {
    47325090        Fibonacci f1, f2;
    4733         for ( int i = 1; i <= 10; i += 1 ) {
    4734                 sout | next( &f1 ) | ' ' | next( &f2 );
    4735         } // for
    4736 }
    4737 \end{cfa}
     5091        for ( 10 ) { $\C{// print N Fibonacci values}$
     5092                sout | next( f1 ) | next( f2 );
     5093        }
     5094}
     5095\end{cfa}
     5096\vspace*{-5pt}
    47385097\caption{Fibonacci Coroutine}
    47395098\label{f:FibonacciCoroutine}
    … …  
    47615120\begin{figure}
    47625121\begin{cfa}
    4763 #include <fstream>
    4764 #include <kernel>
    4765 #include <monitor>
    4766 #include <thread>
    4767 
    4768 monitor global_t {
    4769         int value;
    4770 };
    4771 
    4772 void ?{}(global_t * this) {
    4773         this->value = 0;
    4774 }
    4775 
    4776 static global_t global;
    4777 
    4778 void increment3( global_t * mutex this ) {
    4779         this->value += 1;
    4780 }
    4781 void increment2( global_t * mutex this ) {
    4782         increment3( this );
    4783 }
    4784 void increment( global_t * mutex this ) {
    4785         increment2( this );
    4786 }
     5122#include <fstream.hfa>
     5123#include ®<thread.hfa>®
     5124
     5125®monitor® AtomicCnt { int counter; };
     5126void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
     5127int inc( AtomicCnt & ®mutex® c, int inc = 1 ) with(c) { return counter += inc; }
     5128int dec( AtomicCnt & ®mutex® c, int dec = 1 ) with(c) { return counter -= dec; }
     5129forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
     5130        ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
     5131        void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
     5132}
     5133
     5134AtomicCnt global; $\C{// shared}$
    47875135
    47885136thread MyThread {};
    4789 
    4790 void main( MyThread* this ) {
    4791         for(int i = 0; i < 1_000_000; i++) {
    4792                 increment( &global );
     5137void main( MyThread & ) {
     5138        for ( i; 100_000 ) {
     5139                inc( global );
     5140                dec( global );
    47935141        }
    47945142}
    4795 int main(int argc, char* argv[]) {
    4796         processor p;
     5143int main() {
     5144        enum { Threads = 4 };
     5145        processor p[Threads - 1]; $\C{// + starting processor}$
    47975146        {
    4798                 MyThread f[4];
     5147                MyThread t[Threads];
    47995148        }
    4800         sout | global.value;
     5149        sout | global; $\C{// print 0}$
    48015150}
    48025151\end{cfa}
    48035152\caption{Atomic-Counter Monitor}
    4804 \caption{f:AtomicCounterMonitor}
     5153\label{f:AtomicCounterMonitor}
    48055154\end{figure}
    48065155
    … …  
    62656614
    62666615C has a number of syntax ambiguities, which are resolved by taking the longest sequence of overlapping characters that constitute a token.
    6267 For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]@x ++ ++ + y@ because operator tokens ©++© and ©+© overlap.
    6268 Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]@x ++ + ++ y@ might yield a correct expression.
     6616For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]{x ++ ++ + y} because operator tokens ©++© and ©+© overlap.
     6617Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]{x ++ + ++ y} might yield a correct expression.
    62696618Hence, C programmers are aware that spaces have to added to disambiguate certain syntactic cases.
    62706619
    … …  
    62866635requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
    62876636However, the dereference operator \emph{must} have a parameter/argument to dereference ©*?(...)©.
    6288 Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]@* ?()@ does not preclude any meaningful program.
     6637Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]{* ?()} does not preclude any meaningful program.
    62896638
    62906639The remaining cases are with the increment/decrement operators and conditional expression, \eg:
    … …  
    63946743\begin{cfa}
    63956744int i; $\C{// forward definition}$
    6396 int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$
     6745int *j = ®&i®; $\C{// forward reference, valid in C, invalid in \CFA}$
    63976746int i = 0; $\C{// definition}$
    63986747\end{cfa}
    … …  
    64026751struct X { int i; struct X *next; };
    64036752static struct X a; $\C{// forward definition}$
    6404 static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$
     6753static struct X b = { 0, ®&a® };$\C{// forward reference, valid in C, invalid in \CFA}$
    64056754static struct X a = { 1, &b }; $\C{// definition}$
    64066755\end{cfa}
    … …  
    64156764\item[Change:] have ©struct© introduce a scope for nested types:
    64166765\begin{cfa}
    6417 enum @Colour@ { R, G, B, Y, C, M };
     6766enum ®Colour® { R, G, B, Y, C, M };
    64186767struct Person {
    6419         enum @Colour@ { R, G, B };      $\C[7cm]{// nested type}$
     6768        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
    64206769        struct Face { $\C{// nested type}$
    6421                 @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$
     6770                ®Colour® Eyes, Hair; $\C{// type defined outside (1 level)}$
    64226771        };
    6423         @.Colour@ shirt; $\C{// type defined outside (top level)}$
    6424         @Colour@ pants; $\C{// type defined same level}$
     6772        ®.Colour® shirt; $\C{// type defined outside (top level)}$
     6773        ®Colour® pants; $\C{// type defined same level}$
    64256774        Face looks[10]; $\C{// type defined same level}$
    64266775};
    6427 @Colour@ c = R; $\C{// type/enum defined same level}$
    6428 Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$
    6429 Person@.@Face pretty; $\C{// type defined inside}\CRT$
     6776®Colour® c = R; $\C{// type/enum defined same level}$
     6777Person®.Colour® pc = Person®.®R;$\C{// type/enum defined inside}$
     6778Person®.®Face pretty; $\C{// type defined inside}\CRT$
    64306779\end{cfa}
    64316780In 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.
    … …  
    65026851\label{s:CFAKeywords}
    65036852
    6504 \CFA introduces the following new keywords.
     6853\CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers.
    65056854
    65066855\begin{cquote}
    6507 \input{../refrat/keywords}
     6856\begin{tabular}{@{}lllllll@{}}
     6857\begin{tabular}{@{}l@{}}
     6858\Indexc{basetypeof}             \\
     6859\Indexc{choose}                 \\
     6860\Indexc{coroutine}              \\
     6861\Indexc{disable}                \\
     6862\end{tabular}
     6863&
     6864\begin{tabular}{@{}l@{}}
     6865\Indexc{enable}                 \\
     6866\Indexc{exception}              \\
     6867\Indexc{fallthrough}    \\
     6868\Indexc{fallthru}               \\
     6869\end{tabular}
     6870&
     6871\begin{tabular}{@{}l@{}}
     6872\Indexc{finally}                \\
     6873\Indexc{fixup}                  \\
     6874\Indexc{forall}                 \\
     6875\Indexc{generator}              \\
     6876\end{tabular}
     6877&
     6878\begin{tabular}{@{}l@{}}
     6879\Indexc{int128}                 \\
     6880\Indexc{monitor}                \\
     6881\Indexc{mutex}                  \\
     6882\Indexc{one_t}                  \\
     6883\end{tabular}
     6884&
     6885\begin{tabular}{@{}l@{}}
     6886\Indexc{report}                 \\
     6887\Indexc{suspend}                \\
     6888\Indexc{throw}                  \\
     6889\Indexc{throwResume}    \\
     6890\end{tabular}
     6891&
     6892\begin{tabular}{@{}l@{}}
     6893\Indexc{trait}                  \\
     6894\Indexc{try}                    \\
     6895\Indexc{virtual}                \\
     6896\Indexc{waitfor}                \\
     6897\end{tabular}
     6898&
     6899\begin{tabular}{@{}l@{}}
     6900\Indexc{when}                   \\
     6901\Indexc{with}                   \\
     6902\Indexc{zero_t}                 \\
     6903                                                \\
     6904\end{tabular}
     6905\end{tabular}
    65086906\end{cquote}
    6509 
     6907\CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers.
     6908\begin{cquote}
     6909\begin{tabular}{@{}ll@{}}
     6910\begin{tabular}{@{}l@{}}
     6911\Indexc{catch}                  \\
     6912\Indexc{catchResume}    \\
     6913\Indexc{finally}                \\
     6914\end{tabular}
     6915&
     6916\begin{tabular}{@{}l@{}}
     6917\Indexc{fixup}                  \\
     6918\Indexc{or}                             \\
     6919\Indexc{timeout}                \\
     6920\end{tabular}
     6921\end{tabular}
     6922\end{cquote}
    65106923
    65116924\section{Standard Headers}
    … …  
    66667079// assume ?|? operator for printing an S
    66677080
    6668 S & sp = *@new@( 3 );                                                   $\C{// call constructor after allocation}$
     7081S & sp = *®new®( 3 );                                                   $\C{// call constructor after allocation}$
    66697082sout | sp.i;
    6670 @delete@( &sp );
    6671 
    6672 S * spa = @anew@( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
     7083®delete®( &sp );
     7084
     7085S * spa = ®anew®( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
    66737086for ( i; 10 ) sout | spa[i] | nonl;
    66747087sout | nl;
    6675 @adelete@( 10, spa );
     7088®adelete®( 10, spa );
    66767089\end{cfa}
    66777090Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
    … …  
    69097322[ int, long double ] remquo( long double, long double );
    69107323
    6911 float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
    6912 double div( double, double, int * );
    6913 long double div( long double, long double, int * );
    69147324[ int, float ] div( float, float );
    69157325[ int, double ] div( double, double );
    … …  
    69727382long double _Complex log( long double _Complex );
    69737383
    6974 float log2( float );$\indexc{log2}$
     7384int log2( unsigned int );$\indexc{log2}$
     7385long int log2( unsigned long int );
     7386long long int log2( unsigned long long int )
     7387float log2( float );
    69757388double log2( double );
    69767389long double log2( long double );
    … …  
    71547567\leavevmode
    71557568\begin{cfa}[aboveskip=0pt,belowskip=0pt]
     7569// n / align * align
     7570signed char floor( signed char n, signed char align );
     7571unsigned char floor( unsigned char n, unsigned char align );
     7572short int floor( short int n, short int align );
     7573unsigned short int floor( unsigned short int n, unsigned short int align );
     7574int floor( int n, int align );
     7575unsigned int floor( unsigned int n, unsigned int align );
     7576long int floor( long int n, long int align );
     7577unsigned long int floor( unsigned long int n, unsigned long int align );
     7578long long int floor( long long int n, long long int align );
     7579unsigned long long int floor( unsigned long long int n, unsigned long long int align );
     7580
     7581// (n + (align - 1)) / align
     7582signed char ceiling_div( signed char n, char align );
     7583unsigned char ceiling_div( unsigned char n, unsigned char align );
     7584short int ceiling_div( short int n, short int align );
     7585unsigned short int ceiling_div( unsigned short int n, unsigned short int align );
     7586int ceiling_div( int n, int align );
     7587unsigned int ceiling_div( unsigned int n, unsigned int align );
     7588long int ceiling_div( long int n, long int align );
     7589unsigned long int ceiling_div( unsigned long int n, unsigned long int align );
     7590long long int ceiling_div( long long int n, long long int align );
     7591unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align );
     7592
     7593// floor( n + (n % align != 0 ? align - 1 : 0), align )
     7594signed char ceiling( signed char n, signed char align );
     7595unsigned char ceiling( unsigned char n, unsigned char align );
     7596short int ceiling( short int n, short int align );
     7597unsigned short int ceiling( unsigned short int n, unsigned short int align );
     7598int ceiling( int n, int align );
     7599unsigned int ceiling( unsigned int n, unsigned int align );
     7600long int ceiling( long int n, long int align );
     7601unsigned long int ceiling( unsigned long int n, unsigned long int align );
     7602long long int ceiling( long long int n, long long int align );
     7603unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
     7604
    71567605float floor( float );$\indexc{floor}$
    71577606double floor( double );
    … …  
    72497698
    72507699
    7251 %\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
     7700%\subsection{\texorpdfstring{\protect\lstinline{Duration}}{Duration}}
    72527701\subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}}
    72537702\label{s:Duration}
    … …  
    72567705\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    72577706struct Duration {
    7258         int64_t tv; $\C{// nanoseconds}$
     7707        int64_t tn; $\C{// nanoseconds}$
    72597708};
    72607709
    72617710void ?{}( Duration & dur );
    72627711void ?{}( Duration & dur, zero_t );
     7712void ?{}( Duration & dur, timeval t )
     7713void ?{}( Duration & dur, timespec t )
    72637714
    72647715Duration ?=?( Duration & dur, zero_t );
     7716Duration ?=?( Duration & dur, timeval t )
     7717Duration ?=?( Duration & dur, timespec t )
    72657718
    72667719Duration +?( Duration rhs );
    … …  
    72847737Duration ?%=?( Duration & lhs, Duration rhs );
    72857738
    7286 _Bool ?==?( Duration lhs, Duration rhs );
    7287 _Bool ?!=?( Duration lhs, Duration rhs );
    7288 _Bool ?<? ( Duration lhs, Duration rhs );
    7289 _Bool ?<=?( Duration lhs, Duration rhs );
    7290 _Bool ?>? ( Duration lhs, Duration rhs );
    7291 _Bool ?>=?( Duration lhs, Duration rhs );
    7292 
    7293 _Bool ?==?( Duration lhs, zero_t );
    7294 _Bool ?!=?( Duration lhs, zero_t );
    7295 _Bool ?<? ( Duration lhs, zero_t );
    7296 _Bool ?<=?( Duration lhs, zero_t );
    7297 _Bool ?>? ( Duration lhs, zero_t );
    7298 _Bool ?>=?( Duration lhs, zero_t );
     7739bool ?==?( Duration lhs, zero_t );
     7740bool ?!=?( Duration lhs, zero_t );
     7741bool ?<? ( Duration lhs, zero_t );
     7742bool ?<=?( Duration lhs, zero_t );
     7743bool ?>? ( Duration lhs, zero_t );
     7744bool ?>=?( Duration lhs, zero_t );
     7745
     7746bool ?==?( Duration lhs, Duration rhs );
     7747bool ?!=?( Duration lhs, Duration rhs );
     7748bool ?<? ( Duration lhs, Duration rhs );
     7749bool ?<=?( Duration lhs, Duration rhs );
     7750bool ?>? ( Duration lhs, Duration rhs );
     7751bool ?>=?( Duration lhs, Duration rhs );
    72997752
    73007753Duration abs( Duration rhs );
    … …  
    73237776int64_t ?`w( Duration dur );
    73247777
     7778double ?`dns( Duration dur );
     7779double ?`dus( Duration dur );
     7780double ?`dms( Duration dur );
     7781double ?`ds( Duration dur );
     7782double ?`dm( Duration dur );
     7783double ?`dh( Duration dur );
     7784double ?`dd( Duration dur );
     7785double ?`dw( Duration dur );
     7786
    73257787Duration max( Duration lhs, Duration rhs );
    73267788Duration min( Duration lhs, Duration rhs );
    7327 \end{cfa}
    7328 
    7329 
    7330 %\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
     7789
     7790forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
     7791\end{cfa}
     7792
     7793
     7794%\subsection{\texorpdfstring{\protect\lstinline{timeval}}{timeval}}
    73317795\subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}}
    73327796\label{s:timeval}
    … …  
    73357799\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    73367800void ?{}( timeval & t );
     7801void ?{}( timeval & t, zero_t );
    73377802void ?{}( timeval & t, time_t sec, suseconds_t usec );
    73387803void ?{}( timeval & t, time_t sec );
    7339 void ?{}( timeval & t, zero_t );
    73407804void ?{}( timeval & t, Time time );
    73417805
    … …  
    73437807timeval ?+?( timeval & lhs, timeval rhs );
    73447808timeval ?-?( timeval & lhs, timeval rhs );
    7345 _Bool ?==?( timeval lhs, timeval rhs );
    7346 _Bool ?!=?( timeval lhs, timeval rhs );
    7347 \end{cfa}
    7348 
    7349 
    7350 %\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
     7809bool ?==?( timeval lhs, timeval rhs );
     7810bool ?!=?( timeval lhs, timeval rhs );
     7811\end{cfa}
     7812
     7813
     7814%\subsection{\texorpdfstring{\protect\lstinline{timespec}}{timespec}}
    73517815\subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}}
    73527816\label{s:timespec}
    … …  
    73557819\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    73567820void ?{}( timespec & t );
     7821void ?{}( timespec & t, zero_t );
    73577822void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec );
    73587823void ?{}( timespec & t, time_t sec );
    7359 void ?{}( timespec & t, zero_t );
    73607824void ?{}( timespec & t, Time time );
    73617825
    … …  
    73637827timespec ?+?( timespec & lhs, timespec rhs );
    73647828timespec ?-?( timespec & lhs, timespec rhs );
    7365 _Bool ?==?( timespec lhs, timespec rhs );
    7366 _Bool ?!=?( timespec lhs, timespec rhs );
    7367 \end{cfa}
    7368 
    7369 
    7370 %\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
     7829bool ?==?( timespec lhs, timespec rhs );
     7830bool ?!=?( timespec lhs, timespec rhs );
     7831\end{cfa}
     7832
     7833
     7834%\subsection{\texorpdfstring{\protect\lstinline{itimerval}}{itimerval}}
    73717835\subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}}
    73727836\label{s:itimerval}
    … …  
    73797843
    73807844
    7381 %\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
     7845%\subsection{\texorpdfstring{\protect\lstinline{Time}}{Time}}
    73827846\subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}}
    73837847\label{s:Time}
    … …  
    73867850\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    73877851struct Time {
    7388         uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
     7852        uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
    73897853};
    73907854
    73917855void ?{}( Time & time );
    73927856void ?{}( Time & time, zero_t );
     7857void ?{}( Time & time, timeval t );
     7858void ?{}( Time & time, timespec t );
    73937859
    73947860Time ?=?( Time & time, zero_t );
    7395 
    7396 void ?{}( Time & time, timeval t );
    73977861Time ?=?( Time & time, timeval t );
    7398 
    7399 void ?{}( Time & time, timespec t );
    74007862Time ?=?( Time & time, timespec t );
    74017863
    … …  
    74077869Time ?-?( Time lhs, Duration rhs );
    74087870Time ?-=?( Time & lhs, Duration rhs );
    7409 _Bool ?==?( Time lhs, Time rhs );
    7410 _Bool ?!=?( Time lhs, Time rhs );
    7411 _Bool ?<?( Time lhs, Time rhs );
    7412 _Bool ?<=?( Time lhs, Time rhs );
    7413 _Bool ?>?( Time lhs, Time rhs );
    7414 _Bool ?>=?( Time lhs, Time rhs );
     7871bool ?==?( Time lhs, Time rhs );
     7872bool ?!=?( Time lhs, Time rhs );
     7873bool ?<?( Time lhs, Time rhs );
     7874bool ?<=?( Time lhs, Time rhs );
     7875bool ?>?( Time lhs, Time rhs );
     7876bool ?>=?( Time lhs, Time rhs );
     7877
     7878int64_t ?`ns( Time t );
    74157879
    74167880char * yy_mm_dd( Time time, char * buf );
    7417 char * ?`ymd( Time time, char * buf ) { // short form
    7418         return yy_mm_dd( time, buf );
    7419 } // ymd
     7881char * ?`ymd( Time time, char * buf ); // short form
    74207882
    74217883char * mm_dd_yy( Time time, char * buf );
    7422 char * ?`mdy( Time time, char * buf ) { // short form
    7423         return mm_dd_yy( time, buf );
    7424 } // mdy
     7884char * ?`mdy( Time time, char * buf ); // short form
    74257885
    74267886char * dd_mm_yy( Time time, char * buf );
    7427 char * ?`dmy( Time time, char * buf ) { // short form
    7428         return dd_mm_yy( time, buf );;
    7429 } // dmy
     7887char * ?`dmy( Time time, char * buf ); // short form
    74307888
    74317889size_t strftime( char * buf, size_t size, const char * fmt, Time time );
    7432 forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
     7890
     7891forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
    74337892\end{cfa}
    74347893
    … …  
    74507909
    74517910
    7452 %\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
     7911%\subsection{\texorpdfstring{\protect\lstinline{Clock}}{Clock}}
    74537912\subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}}
    74547913\label{s:Clock}
    … …  
    74567915\leavevmode
    74577916\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7458 struct Clock {
    7459         Duration offset; $\C{// for virtual clock: contains offset from real-time}$
    7460         int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
     7917struct Clock { $\C{// virtual clock}$
     7918        Duration offset; $\C{// offset from computer real-time}$
    74617919};
    74627920
    7463 void resetClock( Clock & clk );
    7464 void resetClock( Clock & clk, Duration adj );
    7465 void ?{}( Clock & clk );
    7466 void ?{}( Clock & clk, Duration adj );
    7467 
    7468 Duration getResNsec(); $\C{// with nanoseconds}$
    7469 Duration getRes(); $\C{// without nanoseconds}$
    7470 
    7471 Time getTimeNsec(); $\C{// with nanoseconds}$
    7472 Time getTime(); $\C{// without nanoseconds}$
    7473 Time getTime( Clock & clk );
    7474 Time ?()( Clock & clk );
    7475 timeval getTime( Clock & clk );
    7476 tm getTime( Clock & clk );
     7921void ?{}( Clock & clk ); $\C{// create no offset}$
     7922void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
     7923void reset( Clock & clk, Duration adj ); $\C{// change offset}$
     7924
     7925Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
     7926Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
     7927
     7928Time timeHiRes(); $\C{// real time with nanoseconds}$
     7929Time time(); $\C{// real time without nanoseconds}$
     7930Time time( Clock & clk ); $\C{// real time for given clock}$
     7931Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
     7932timeval time( Clock & clk ); $\C{// convert to C time format}$
     7933tm time( Clock & clk );
     7934Duration processor(); $\C{// non-monotonic duration of kernel thread}$
     7935Duration program(); $\C{// non-monotonic duration of program CPU}$
     7936Duration boot(); $\C{// monotonic duration since computer boot}$
    74777937\end{cfa}
    74787938
    … …  
    76458105forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
    76468106\end{cfa}
    7647 
    7648 The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
     8107\VRef[Figure]{f:MultiPrecisionFactorials} shows \CFA and C factorial programs using the GMP interfaces.
    76498108(Compile with flag \Indexc{-lgmp} to link with the GMP library.)
     8109
     8110\begin{figure}
    76508111\begin{cquote}
    76518112\begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
    7652 \multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
     8113\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
    76538114\hline
    76548115\begin{cfa}
    … …  
    76598120
    76608121        sout | 0 | fact;
    7661         for ( unsigned int i = 1; i <= 40; i += 1 ) {
     8122        for ( i; 40 ) {
    76628123                fact *= i;
    76638124                sout | i | fact;
    … …  
    76698130#include <gmp.h>$\indexc{gmp.h}$
    76708131int main( void ) {
    7671         @gmp_printf@( "Factorial Numbers\n" );
    7672         @mpz_t@ fact;
    7673         @mpz_init_set_ui@( fact, 1 );
    7674         @gmp_printf@( "%d %Zd\n", 0, fact );
     8132        ®gmp_printf®( "Factorial Numbers\n" );
     8133        ®mpz_t® fact;
     8134        ®mpz_init_set_ui®( fact, 1 );
     8135        ®gmp_printf®( "%d %Zd\n", 0, fact );
    76758136        for ( unsigned int i = 1; i <= 40; i += 1 ) {
    7676                 @mpz_mul_ui@( fact, fact, i );
    7677                 @gmp_printf@( "%d %Zd\n", i, fact );
     8137                ®mpz_mul_ui®( fact, fact, i );
     8138                ®gmp_printf®( "%d %Zd\n", i, fact );
    76788139        }
    76798140}
    … …  
    76818142\end{tabular}
    76828143\end{cquote}
    7683 
    7684 \begin{figure}
     8144\small
    76858145\begin{cfa}
    76868146Factorial Numbers
Note: See TracChangeset for help on using the changeset viewer.