Changeset adaee12

Timestamp:

Apr 28, 2021, 1:06:13 PM (4 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:

b7fd2db6

Parents:

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

Message:

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

Files:

• doc/user/user.tex (modified) (131 diffs)
• libcfa/src/concurrency/coroutine.cfa (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (2 diffs)
• libcfa/src/concurrency/stats.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (2 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (2 diffs)
• libcfa/src/exception.hfa (modified) (1 diff)
• libcfa/src/fstream.cfa (modified) (2 diffs)
• libcfa/src/fstream.hfa (modified) (5 diffs)
• libcfa/src/iostream.cfa (modified) (11 diffs)
• libcfa/src/iostream.hfa (modified) (16 diffs)
• libcfa/src/strstream.cfa (modified) (8 diffs)
• libcfa/src/strstream.hfa (modified) (3 diffs)
• src/Parser/parser.yy (modified) (5 diffs)
• tests/io/io-acquire.cfa (modified) (2 diffs)
• tests/strstream.cfa (modified) (1 diff)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Apr 20 23:25:56 2021
-%% Update Count     : 4888
+%% Last Modified On : Sun Apr 25 19:03:03 2021
+%% Update Count     : 4951
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -70 +70 @@
 \lstset{language=CFA}                                                                   % CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
-{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}}
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
 {}
 
@@ -82 +82 @@
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
-\newcommand{\R}[1]{\Textbf{#1}}
-\newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}
+\newcommand{\R}[1]{{\color{red}#1}}
+\newcommand{\RB}[1]{\Textbf{#1}}
 \newcommand{\B}[1]{{\Textbf[blue]{#1}}}
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
@@ -177 +177 @@
 int main( void ) {
         int x = 0, y = 1, z = 2;
-        @printf( "%d %d %d\n", x, y, z );@
+        ®printf( "%d %d %d\n", x, y, z );®
 }
 \end{cfa}
@@ -186 +186 @@
 int main( void ) {
         int x = 0, y = 1, z = 2;
-        @sout | x | y | z;@$\indexc{sout}$
+        ®sout | x | y | z;®$\indexc{sout}$
 }
 \end{cfa}
@@ -195 +195 @@
 int main() {
         int x = 0, y = 1, z = 2;
-        @cout<<x<<" "<<y<<" "<<z<<endl;@
+        ®cout<<x<<" "<<y<<" "<<z<<endl;®
 }
 \end{cfa}
@@ -225 +225 @@
 \begin{tabular}{@{}rcccccccc@{}}
                 & 2021  & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986  \\ \hline
-\R{C}   & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\
+\RB{C}  & \RB{1}& \RB{2}& \RB{2}& \RB{1}& \RB{1}& \RB{1}& \RB{1}& \RB{1}\\
 Java    & 2             & 1             & 1             & 2             & 3             & 28    & -             & -             \\
 Python  & 3             & 5             & 6             & 7             & 23    & 13    & -             & -             \\
@@ -259 +259 @@
 The 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):
 \begin{cfa}
-@forall( otype T )@ T identity( T val ) { return val; }
+®forall( otype T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
 \end{cfa}
@@ -323 +323 @@
 Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
 \begin{cfa}
-char @abs@( char );
-extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$
-long int @abs@( long int );
-long long int @abs@( long long int );
-float @abs@( float );
-double @abs@( double );
-long double @abs@( long double );
-float _Complex @abs@( float _Complex );
-double _Complex @abs@( double _Complex );
-long double _Complex @abs@( long double _Complex );
+char ®abs®( char );
+extern "C" { int ®abs®( int ); } $\C{// use default C routine for int}$
+long int ®abs®( long int );
+long long int ®abs®( long long int );
+float ®abs®( float );
+double ®abs®( double );
+long double ®abs®( long double );
+float _Complex ®abs®( float _Complex );
+double _Complex ®abs®( double _Complex );
+long double _Complex ®abs®( long double _Complex );
 \end{cfa}
 The problem is \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).
@@ -359 +359 @@
 The 2011 C standard plus GNU extensions.
 \item
-\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]{-fgnu89-inline}}}
 Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
 \end{description}
@@ -531 +531 @@
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
-int @``@otype = 3; $\C{// make keyword an identifier}$
-double @``@forall = 3.5;
+int ®``®otype = 3; $\C{// make keyword an identifier}$
+double ®``®forall = 3.5;
 \end{cfa}
 
@@ -543 +543 @@
 // include file uses the CFA keyword "with".
 #if ! defined( with )                                                   $\C{// nesting ?}$
-#define with @``@with                                                   $\C{// make keyword an identifier}$
+#define with ®``®with                                                   $\C{// make keyword an identifier}$
 #define __CFA_BFD_H__
 #endif
@@ -561 +561 @@
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
 \begin{cfa}
-2@_@147@_@483@_@648; $\C{// decimal constant}$
-56@_@ul; $\C{// decimal unsigned long constant}$
-0@_@377; $\C{// octal constant}$
-0x@_@ff@_@ff; $\C{// hexadecimal constant}$
-0x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$
-3.141@_@592@_@654; $\C{// floating constant}$
-10@_@e@_@+1@_@00; $\C{// floating constant}$
-0x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$
-0x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$
-L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$
+2®_®147®_®483®_®648; $\C{// decimal constant}$
+56®_®ul; $\C{// decimal unsigned long constant}$
+0®_®377; $\C{// octal constant}$
+0x®_®ff®_®ff; $\C{// hexadecimal constant}$
+0x®_®ef3d®_®aa5c; $\C{// hexadecimal constant}$
+3.141®_®592®_®654; $\C{// floating constant}$
+10®_®e®_®+1®_®00; $\C{// floating constant}$
+0x®_®ff®_®ff®_®p®_®3; $\C{// hexadecimal floating}$
+0x®_®1.ffff®_®ffff®_®p®_®128®_®l; $\C{// hexadecimal floating long constant}$
+L®_®$"\texttt{\textbackslash{x}}$®_®$\texttt{ff}$®_®$\texttt{ee}"$; $\C{// wide character constant}$
 \end{cfa}
 The rules for placement of underscores are:
@@ -603 +603 @@
 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
 \begin{cfa}
-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
-           | (1.0f+2.0fi) @\@ (3.0f+2.0fi);
-1 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@ -0.015625 18.3791736799526 0.264715-1.1922i
+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
+           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+1 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
 \end{cfa}
 Note, ©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.
@@ -613 +613 @@
 \begin{cfa}
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
-T ?@\@?( T ep, unsigned int y );
+T ?®\®?( T ep, unsigned int y );
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
-T ?@\@?( T ep, unsigned long int y );
+T ?®\®?( T ep, unsigned long int y );
 \end{cfa}
 The user type ©T© must define multiplication, one (©1©), and ©*©.
@@ -625 +625 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{if}/\protect\lstinline{while} Statement}{if Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
 
@@ -631 +631 @@
 Declarations in the ©do©-©while© condition are not useful because they appear after the loop body.}
 \begin{cfa}
-if ( @int x = f()@ ) ... $\C{// x != 0}$
-if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
-if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
-if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$
-
-while ( @int x = f()@ ) ... $\C{// x != 0}$
-while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
-while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
-while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$
+if ( ®int x = f()® ) ... $\C{// x != 0}$
+if ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+if ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+if ( ®struct S { int i; } x = { f() }; x.i < 4® ) $\C{// relational expression}$
+
+while ( ®int x = f()® ) ... $\C{// x != 0}$
+while ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+while ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... $\C{// relational expression}$
 \end{cfa}
 Unless 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.
@@ -646 +646 @@
 
 
-%\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
+%\section{\texorpdfstring{\protect\lstinline{case} Clause}{case Clause}}
 \subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
 \label{s:caseClause}
@@ -659 +659 @@
 \begin{cfa}
 switch ( i ) {
-  case @1, 3, 5@:
+  case ®1, 3, 5®:
         ...
-  case @2, 4, 6@:
+  case ®2, 4, 6®:
         ...
 }
@@ -686 +686 @@
 \end{cquote}
 In addition, subranges are allowed to specify case values.\footnote{
-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.}
+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.}
 \begin{cfa}
 switch ( i ) {
-  case @1~5:@ $\C{// 1, 2, 3, 4, 5}$
+  case ®1~5:® $\C{// 1, 2, 3, 4, 5}$
         ...
-  case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$
+  case ®10~15:® $\C{// 10, 11, 12, 13, 14, 15}$
         ...
 }
@@ -697 +697 @@
 Lists of subranges are also allowed.
 \begin{cfa}
-case @1~5, 12~21, 35~42@:
-\end{cfa}
-
-
-%\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
+case ®1~5, 12~21, 35~42®:
+\end{cfa}
+
+
+%\section{\texorpdfstring{\protect\lstinline{switch} Statement}{switch Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
 
@@ -741 +741 @@
 if ( argc == 3 ) {
         // open output file
-        @// open input file
-@} else if ( argc == 2 ) {
-        @// open input file (duplicate)
-
-@} else {
+        ®// open input file
+®} else if ( argc == 2 ) {
+        ®// open input file (duplicate)
+
+®} else {
         // usage message
 }
@@ -756 +756 @@
 \begin{cfa}
 switch ( i ) {
-  @case 1: case 3: case 5:@     // odd values
+  ®case 1: case 3: case 5:®     // odd values
         // odd action
         break;
-  @case 2: case 4: case 6:@     // even values
+  ®case 2: case 4: case 6:®     // even values
         // even action
         break;
@@ -775 +775 @@
         if ( j < k ) {
                 ...
-          @case 1:@             // transfer into "if" statement
+          ®case 1:®             // transfer into "if" statement
                 ...
         } // if
@@ -781 +781 @@
         while ( j < 5 ) {
                 ...
-          @case 3:@             // transfer into "while" statement
+          ®case 3:®             // transfer into "while" statement
                 ...
         } // while
@@ -822 +822 @@
 \begin{cfa}
 switch ( x ) {
-        @int y = 1;@ $\C{// unreachable initialization}$
-        @x = 7;@ $\C{// unreachable code without label/branch}$
+        ®int y = 1;® $\C{// unreachable initialization}$
+        ®x = 7;® $\C{// unreachable code without label/branch}$
   case 0: ...
         ...
-        @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$
+        ®int z = 0;® $\C{// unreachable initialization, cannot appear after case}$
         z = 2;
   case 1:
-        @x = z;@ $\C{// without fall through, z is uninitialized}$
+        ®x = z;® $\C{// without fall through, z is uninitialized}$
 }
 \end{cfa}
@@ -861 +861 @@
 Therefore, 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:
 \begin{cfa}
-@choose@ ( i ) {
+®choose® ( i ) {
   case 1:  case 2:  case 3:
         ...
-        @// implicit end of switch (break)
-  @case 5:
+        ®// implicit end of switch (break)
+  ®case 5:
         ...
-        @fallthru@; $\C{// explicit fall through}$
+        ®fallthru®; $\C{// explicit fall through}$
   case 7:
         ...
-        @break@ $\C{// explicit end of switch (redundant)}$
+        ®break® $\C{// explicit end of switch (redundant)}$
   default:
         j = 3;
@@ -891 +891 @@
 \begin{cfa}
 switch ( x ) {
-        @int i = 0;@ $\C{// allowed only at start}$
+        ®int i = 0;® $\C{// allowed only at start}$
   case 0:
         ...
-        @int j = 0;@ $\C{// disallowed}$
+        ®int j = 0;® $\C{// disallowed}$
   case 1:
         {
-                @int k = 0;@ $\C{// allowed at different nesting levels}$
+                ®int k = 0;® $\C{// allowed at different nesting levels}$
                 ...
-          @case 2:@ $\C{// disallow case in nested statements}$
+          ®case 2:® $\C{// disallow case in nested statements}$
         }
   ...
@@ -916 +916 @@
   case 3:
         if ( ... ) {
-                ... @fallthru;@ // goto case 4
+                ... ®fallthru;® // goto case 4
         } else {
                 ...
@@ -931 +931 @@
 choose ( ... ) {
   case 3:
-        ... @fallthrough common;@
+        ... ®fallthrough common;®
   case 4:
-        ... @fallthrough common;@
-
-  @common:@ // below fallthrough
+        ... ®fallthrough common;®
+
+  ®common:® // below fallthrough
                           // at case-clause level
         ...     // common code for cases 3/4
@@ -951 +951 @@
                 for ( ... ) {
                         // multi-level transfer
-                        ... @fallthru common;@
+                        ... ®fallthru common;®
                 }
                 ...
         }
         ...
-  @common:@ // below fallthrough
+  ®common:® // below fallthrough
                           // at case-clause level
 \end{cfa}
@@ -971 +971 @@
 \hline
 \begin{cfa}
-while @($\,$)@ { sout | "empty"; break; }
-do { sout | "empty"; break; } while @($\,$)@;
-for @($\,$)@ { sout | "empty"; break; }
-for ( @0@ ) { sout | "A"; } sout | "zero";
-for ( @1@ ) { sout | "A"; }
-for ( @10@ ) { sout | "A"; }
-for ( @= 10@ ) { sout | "A"; }
-for ( @1 ~= 10 ~ 2@ ) { sout | "B"; }
-for ( @10 -~= 1 ~ 2@ ) { sout | "C"; }
-for ( @0.5 ~ 5.5@ ) { sout | "D"; }
-for ( @5.5 -~ 0.5@ ) { sout | "E"; }
-for ( @i; 10@ ) { sout | i; }
-for ( @i; = 10@ ) { sout | i; }
-for ( @i; 1 ~= 10 ~ 2@ ) { sout | i; }
-for ( @i; 10 -~= 1 ~ 2@ ) { sout | i; }
-for ( @i; 0.5 ~ 5.5@ ) { sout | i; }
-for ( @i; 5.5 -~ 0.5@ ) { sout | i; }
-for ( @ui; 2u ~= 10u ~ 2u@ ) { sout | ui; }
-for ( @ui; 10u -~= 2u ~ 2u@ ) { sout | ui; }
+while ®($\,$)® { sout | "empty"; break; }
+do { sout | "empty"; break; } while ®($\,$)®;
+for ®($\,$)® { sout | "empty"; break; }
+for ( ®0® ) { sout | "A"; } sout | "zero";
+for ( ®1® ) { sout | "A"; }
+for ( ®10® ) { sout | "A"; }
+for ( ®= 10® ) { sout | "A"; }
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
+for ( ®0.5 ~ 5.5® ) { sout | "D"; }
+for ( ®5.5 -~ 0.5® ) { sout | "E"; }
+for ( ®i; 10® ) { sout | i; }
+for ( ®i; = 10® ) { sout | i; }
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
 enum { N = 10 };
-for ( @N@ ) { sout | "N"; }
-for ( @i; N@ ) { sout | i; }
-for ( @i; N -~ 0@ ) { sout | i; }
+for ( ®N® ) { sout | "N"; }
+for ( ®i; N® ) { sout | i; }
+for ( ®i; N -~ 0® ) { sout | i; }
 const int start = 3, comp = 10, inc = 2;
-for ( @i; start ~ comp ~ inc + 1@ ) { sout | i; }
-for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout | i; }
-for ( i; 10 -~ $\R{@}$ ) { if ( i < 0 ) break; sout | i; }
-for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout | i; }
-for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
-for ( i; 10 -~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout | i; }
-for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
-for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
-for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
-for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
-for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j | k; }
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
+for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
+for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
+for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
+for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
+for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
+for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
 \end{cfa}
 &
@@ -1090 +1090 @@
 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
 \begin{cfa}
-for ( i; @5@ )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
-for ( i; @1.5@~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
+for ( i; ®5® )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
+for ( i; ®1.5®~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
 \end{cfa}
 \item
 An empty conditional implies comparison value of ©1© (true).
 \begin{cfa}
-while ( $\R{/*empty*/}$ )               $\C{// while ( true )}$
-for ( $\R{/*empty*/}$ )                 $\C{// for ( ; true; )}$
-do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$
+while ( ®/*empty*/®  )                  $\C{// while ( true )}$
+for ( ®/*empty*/®  )                    $\C{// for ( ; true; )}$
+do ... while ( ®/*empty*/®  )    $\C{// do ... while ( true )}$
 \end{cfa}
 \item
 A comparison N is implicit up-to exclusive range [0,N\R{)}.
 \begin{cfa}
-for ( @5@ )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
+for ( ®5® )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
 \end{cfa}
 \item
 A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.
 \begin{cfa}
-for ( @=@5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
+for ( ®=®5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}.
 \begin{cfa}
-for ( 1@~@5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
+for ( 1®~®5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}.
 \begin{cfa}
-for ( 1@~=@5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
+for ( 1®~=®5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M\R{)}.
 \begin{cfa}
-for ( 1@-~@5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
+for ( 1®-~®5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M\R{]}.
 \begin{cfa}
-for ( 1@-~=@5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
+for ( 1®-~=®5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
 \end{cfa}
 \item
 ©@© means put nothing in this field.
 \begin{cfa}
-for ( 1~$\R{@}$~2 )                             $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
+for ( 1~®@®~2 )                                 $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
 \end{cfa}
 \item
 ©:© means start another index.
 \begin{cfa}
-for ( i; 5 @:@ j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
+for ( i; 5 ®:® j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
 \end{cfa}
 \end{itemize}
 
 
-%\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
+%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 
@@ -1158 +1158 @@
 \begin{lrbox}{\myboxA}
 \begin{cfa}[tabsize=3]
-@Compound:@ {
-        @Try:@ try {
-                @For:@ for ( ... ) {
-                        @While:@ while ( ... ) {
-                                @Do:@ do {
-                                        @If:@ if ( ... ) {
-                                                @Switch:@ switch ( ... ) {
+®Compound:® {
+        ®Try:® try {
+                ®For:® for ( ... ) {
+                        ®While:® while ( ... ) {
+                                ®Do:® do {
+                                        ®If:® if ( ... ) {
+                                                ®Switch:® switch ( ... ) {
                                                         case 3:
-                                                                @break Compound@;
-                                                                @break Try@;
-                                                                @break For@;      /* or */  @continue For@;
-                                                                @break While@;  /* or */  @continue While@;
-                                                                @break Do@;      /* or */  @continue Do@;
-                                                                @break If@;
-                                                                @break Switch@;
+                                                                ®break Compound®;
+                                                                ®break Try®;
+                                                                ®break For®;      /* or */  ®continue For®;
+                                                                ®break While®;  /* or */  ®continue While®;
+                                                                ®break Do®;      /* or */  ®continue Do®;
+                                                                ®break If®;
+                                                                ®break Switch®;
                                                         } // switch
                                                 } else {
-                                                        ... @break If@; ...     // terminate if
+                                                        ... ®break If®; ...     // terminate if
                                                 } // if
                                 } while ( ... ); // do
                         } // while
                 } // for
-        } @finally@ { // always executed
+        } ®finally® { // always executed
         } // try
 } // compound
@@ -1190 +1190 @@
 {
 
-                @ForC:@ for ( ... ) {
-                        @WhileC:@ while ( ... ) {
-                                @DoC:@ do {
+                ®ForC:® for ( ... ) {
+                        ®WhileC:® while ( ... ) {
+                                ®DoC:® do {
                                         if ( ... ) {
                                                 switch ( ... ) {
                                                         case 3:
-                                                                @goto Compound@;
-                                                                @goto Try@;
-                                                                @goto ForB@;      /* or */  @goto ForC@;
-                                                                @goto WhileB@;  /* or */  @goto WhileC@;
-                                                                @goto DoB@;      /* or */  @goto DoC@;
-                                                                @goto If@;
-                                                                @goto Switch@;
-                                                        } @Switch:@ ;
+                                                                ®goto Compound®;
+                                                                ®goto Try®;
+                                                                ®goto ForB®;      /* or */  ®goto ForC®;
+                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
+                                                                ®goto DoB®;      /* or */  ®goto DoC®;
+                                                                ®goto If®;
+                                                                ®goto Switch®;
+                                                        } ®Switch:® ;
                                                 } else {
-                                                        ... @goto If@; ...      // terminate if
-                                                } @If:@;
-                                } while ( ... ); @DoB:@ ;
-                        } @WhileB:@ ;
-                } @ForB:@ ;
-
-
-} @Compound:@ ;
+                                                        ... ®goto If®; ...      // terminate if
+                                                } ®If:®;
+                                } while ( ... ); ®DoB:® ;
+                        } ®WhileB:® ;
+                } ®ForB:® ;
+
+
+} ®Compound:® ;
 \end{cfa}
 \end{lrbox}
@@ -1241 +1241 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{with} Statement}{with Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
 \label{s:WithStatement}
@@ -1256 +1256 @@
 \begin{cfa}
 Person p
-@p.@name; @p.@address; @p.@sex; $\C{// access containing fields}$
+®p.®name; ®p.®address; ®p.®sex; $\C{// access containing fields}$
 \end{cfa}
 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
 \begin{cfa}
 struct Ticket { ... } t;
-@p.name@.first; @p.address@.street;             $\C{// access nested fields}$
-@t.@departure; @t.@cost;                                $\C{// access multiple aggregate}$
+®p.name®.first; ®p.address®.street;             $\C{// access nested fields}$
+®t.®departure; ®t.®cost;                                $\C{// access multiple aggregate}$
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
@@ -1285 +1285 @@
 \begin{C++}
 struct S {
-        char @c@;   int @i@;   double @d@;
+        char ®c®;   int ®i®;   double ®d®;
         void f( /* S * this */ ) {                              $\C{// implicit ``this'' parameter}$
-                @c@;   @i@;   @d@;                                      $\C{// this->c; this->i; this->d;}$
+                ®c®;   ®i®;   ®d®;                                      $\C{// this->c; this->i; this->d;}$
         }
 }
@@ -1295 +1295 @@
 \begin{cfa}
 struct T {
-        char @m@;   int @i@;   double @n@;              $\C{// derived class variables}$
+        char ®m®;   int ®i®;   double ®n®;              $\C{// derived class variables}$
 };
 struct S : public T {
-        char @c@;   int @i@;   double @d@;              $\C{// class variables}$
-        void g( double @d@, T & t ) {
-                d;   @t@.m;   @t@.i;   @t@.n;           $\C{// function parameter}$
-                c;   i;   @this->@d;   @S::@d;          $\C{// class S variables}$
-                m;   @T::@i;   n;                                       $\C{// class T variables}$
+        char ®c®;   int ®i®;   double ®d®;              $\C{// class variables}$
+        void g( double ®d®, T & t ) {
+                d;   ®t®.m;   ®t®.i;   ®t®.n;           $\C{// function parameter}$
+                c;   i;   ®this->®d;   ®S::®d;          $\C{// class S variables}$
+                m;   ®T::®i;   n;                                       $\C{// class T variables}$
         }
 };
@@ -1312 +1312 @@
 Hence, 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.
 \begin{cfa}
-void f( S & this ) @with ( this )@ {            $\C{// with statement}$
-        @c@;   @i@;   @d@;                                              $\C{// this.c, this.i, this.d}$
+void f( S & this ) ®with ( this )® {            $\C{// with statement}$
+        ®c®;   ®i®;   ®d®;                                              $\C{// this.c, this.i, this.d}$
 }
 \end{cfa}
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
-void g( S & s, T & t ) @with ( s, t )@ {        $\C{// multiple aggregate parameters}$
-        c;   @s.@i;   d;                                                $\C{// s.c, s.i, s.d}$
-        m;   @t.@i;   n;                                                $\C{// t.m, t.i, t.n}$
+void g( S & s, T & t ) ®with ( s, t )® {        $\C{// multiple aggregate parameters}$
+        c;   ®s.®i;   d;                                                $\C{// s.c, s.i, s.d}$
+        m;   ®t.®i;   n;                                                $\C{// t.m, t.i, t.n}$
 }
 \end{cfa}
@@ -1339 +1339 @@
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
-struct Q { int @i@; int k; int @m@; } q, w;
-struct R { int @i@; int j; double @m@; } r, w;
+struct Q { int ®i®; int k; int ®m®; } q, w;
+struct R { int ®i®; int j; double ®m®; } r, w;
 with ( r, q ) {
         j + k;                                                                  $\C{// unambiguous, r.j + q.k}$
@@ -1373 +1373 @@
 \begin{cfa}
 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$
-        @s.i = i;@  j = 3;  m = 5.5; $\C{// initialize fields}$
+        ®s.i = i;®  j = 3;  m = 5.5; $\C{// initialize fields}$
 }
 \end{cfa}
@@ -1386 +1386 @@
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
-void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { // syntax not allowed, illustration only
-        s.i = @i@; j = 3; m = 5.5;
+void ?{}( S & s, int ®i® ) with ( s ) ®with( $\emph{\R{params}}$ )® { // syntax not allowed, illustration only
+        s.i = ®i®; j = 3; m = 5.5;
 }
 \end{cfa}
@@ -1470 +1470 @@
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
-int @(*@f@())[@5@]@ {...}; $\C{// definition}$
- ... @(*@f@())[@3@]@ += 1; $\C{// usage}$
+int ®(*®f®())[®5®]® {...}; $\C{// definition}$
+ ... ®(*®f®())[®3®]® += 1; $\C{// usage}$
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
@@ -1487 +1487 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
-#[5] *# @int@ x1;
-#* [5]# @int@ x2;
-#[* [5] int]# f@( int p )@;
+#[5] *# ®int® x1;
+#* [5]# ®int® x2;
+#[* [5] int]# f®( int p )®;
 \end{cfa}
 &
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
-@int@ #*# x1 #[5]#;
-@int@ #(*#x2#)[5]#;
-#int (*#f@( int p )@#)[5]#;
+®int® #*# x1 #[5]#;
+®int® #(*#x2#)[5]#;
+#int (*#f®( int p )®#)[5]#;
 \end{cfa}
 \end{tabular}
@@ -1507 +1507 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
-@*@ int x, y;
+®*® int x, y;
 \end{cfa}
 &
 \begin{cfa}
-int @*@x, @*@y;
+int ®*®x, ®*®y;
 \end{cfa}
 \end{tabular}
@@ -1520 +1520 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
-@*@ int x;
+®*® int x;
 int y;
 \end{cfa}
 &
 \begin{cfa}
-int @*@x, y;
+int ®*®x, y;
 
 \end{cfa}
@@ -1661 +1661 @@
 &
 \begin{cfa}
-int * @const@ x = (int *)100
+int * ®const® x = (int *)100
 *x = 3;                 // implicit dereference
-int * @const@ y = (int *)104;
+int * ®const® y = (int *)104;
 *y = *x;                        // implicit dereference
 \end{cfa}
@@ -1701 +1701 @@
 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
 \begin{cfa}
-int x, y, @*@ p1, @*@ p2, @**@ p3;
-p1 = @&@x;     // p1 points to x
+int x, y, ®*® p1, ®*® p2, ®**® p3;
+p1 = ®&®x;     // p1 points to x
 p2 = p1;     // p2 points to x
-p1 = @&@y;     // p1 points to y
+p1 = ®&®y;     // p1 points to y
 p3 = &p2;  // p3 points to p2
 \end{cfa}
@@ -1730 +1730 @@
 \begin{cfa}
 p1 = p2; $\C{// pointer address assignment}$
-@*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$
+®*®p2 = ®*®p1 + x; $\C{// pointed-to value assignment / operation}$
 \end{cfa}
 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
@@ -1746 +1746 @@
 To 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).
 \begin{cfa}
-int x, y, @&@ r1, @&@ r2, @&&@ r3;
-@&@r1 = &x; $\C{// r1 points to x}$
-@&@r2 = &r1; $\C{// r2 points to x}$
-@&@r1 = &y; $\C{// r1 points to y}$
-@&&@r3 = @&@&r2; $\C{// r3 points to r2}$
+int x, y, ®&® r1, ®&® r2, ®&&® r3;
+®&®r1 = &x; $\C{// r1 points to x}$
+®&®r2 = &r1; $\C{// r2 points to x}$
+®&®r1 = &y; $\C{// r1 points to y}$
+®&&®r3 = ®&®&r2; $\C{// r3 points to r2}$
 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
 \end{cfa}
@@ -1757 +1757 @@
 One 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:
 \begin{cfa}
-@*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);
+®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
 \end{cfa}
 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
@@ -1766 +1766 @@
 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
 \begin{cfa}
-(&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
+(&®*®)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
 \end{cfa}
 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
 \begin{cfa}
-(&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
+(&(&®*®)®*®)r3 = &(&®*®)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
 \end{cfa}
 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
@@ -1793 +1793 @@
 const int cx = 5; $\C{// cannot change cx;}$
 const int & cr = cx; $\C{// cannot change what cr points to}$
-@&@cr = &cx; $\C{// can change cr}$
+®&®cr = &cx; $\C{// can change cr}$
 cr = 7; $\C{// error, cannot change cx}$
 int & const rc = x; $\C{// must be initialized}$
-@&@rc = &x; $\C{// error, cannot change rc}$
+®&®rc = &x; $\C{// error, cannot change rc}$
 const int & const crc = cx; $\C{// must be initialized}$
 crc = 7; $\C{// error, cannot change cx}$
-@&@crc = &cx; $\C{// error, cannot change crc}$
+®&®crc = &cx; $\C{// error, cannot change crc}$
 \end{cfa}
 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
@@ -1820 +1820 @@
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
-@const@ * @const@ * const int ccp;
-@const@ & @const@ & const int ccr;
+®const® * ®const® * const int ccp;
+®const® & ®const® & const int ccr;
 \end{cfa}
 &
 \begin{cfa}
-const int * @const@ * @const@ ccp;
+const int * ®const® * ®const® ccp;
 
 \end{cfa}
@@ -1857 +1857 @@
 \begin{cfa}
 int * p = &x; $\C{// assign address of x}$
-@int * p = x;@ $\C{// assign value of x}$
+®int * p = x;® $\C{// assign value of x}$
 int & r = x; $\C{// must have address of x}$
 \end{cfa}
@@ -1881 +1881 @@
 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
 \begin{cfa}
-void f( @const@ int & cr );
-void g( @const@ int * cp );
-f( 3 );                   g( @&@3 );
-f( x + y );             g( @&@(x + y) );
+void f( ®const® int & cr );
+void g( ®const® int * cp );
+f( 3 );                   g( ®&®3 );
+f( x + y );             g( ®&®(x + y) );
 \end{cfa}
 Here, 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.
@@ -1895 +1895 @@
 void f( int & r );
 void g( int * p );
-f( 3 );                   g( @&@3 ); $\C{// compiler implicit generates temporaries}$
-f( x + y );             g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$
+f( 3 );                   g( ®&®3 ); $\C{// compiler implicit generates temporaries}$
+f( x + y );             g( ®&®(x + y) ); $\C{// compiler implicit generates temporaries}$
 \end{cfa}
 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
@@ -1917 +1917 @@
 Instead, a routine object should be referenced by a ©const© reference:
 \begin{cfa}
-@const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$
+®const® void (®&® fr)( int ) = f; $\C{// routine reference}$
 fr = ... $\C{// error, cannot change code}$
 &fr = ...; $\C{// changing routine reference}$
@@ -1979 +1979 @@
 \begin{cfa}
 int x, &r = x, f( int p );
-x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$
+x = ®r® + f( ®r® ); $\C{// lvalue reference converts to rvalue}$
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
 
 \item
-lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
-\begin{cfa}
-int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
-f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+lvalue to reference conversion: \lstinline[deletekeywords=lvalue]{lvalue-type cv1 T} converts to ©cv2 T &©, which allows implicitly converting variables to references.
+\begin{cfa}
+int x, &r = ®x®, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}$
 \end{cfa}
 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
@@ -1997 +1997 @@
 \begin{cfa}
 int x, & f( int & p );
-f( @x + 3@ );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
-@&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
+f( ®x + 3® );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
+®&f®(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
 \end{cfa}
 In both case, modifications to the temporary are inaccessible (\Index{warning}).
@@ -2224 +2224 @@
 \CFA allows other integral types with associated values.
 \begin{cfa}
-enum( @char@ ) Letter { A @= 'A'@,  B,  C,  I @= 'I'@,  J,  K };
-enum( @long long int@ ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
+enum( ®char® ) Letter { A ®= 'A'®,  B,  C,  I ®= 'I'®,  J,  K };
+enum( ®long long int® ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
 \end{cfa}
 For 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©.
@@ -2232 +2232 @@
 \begin{cfa}
 // non-integral numeric
-enum( @double@ ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
 // pointer
-enum( @char *@ ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
 int i, j, k;
-enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
-enum( @int &@ ) ref { I = i,  J = j,  K = k };
+enum( ®int *® ) ptr { I = &i,  J = &j,  K = &k };
+enum( ®int &® ) ref { I = i,  J = j,  K = k };
 // tuple
-enum( @[int, int]@ ) { T = [ 1, 2 ] };
+enum( ®[int, int]® ) { T = [ 1, 2 ] };
 // function
 void f() {...}   void g() {...}
-enum( @void (*)()@ ) funs { F = f,  F = g };
+enum( ®void (*)()® ) funs { F = f,  F = g };
 // aggregate
 struct S { int i, j; };
-enum( @S@ ) s { A = { 3,  4 }, B = { 7,  8 } };
+enum( ®S® ) s { A = { 3,  4 }, B = { 7,  8 } };
 // enumeration
-enum( @Letter@ ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
+enum( ®Letter® ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
 \end{cfa}
 Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
@@ -2270 +2270 @@
 A fallback is explicit C-style initialization using ©@=©.
 \begin{cfa}
-enum( struct vec3 ) Axis { Up $@$= { 1, 0, 0 }, Left $@$= { 0, 1, 0 }, Front $@$= { 0, 0, 1 } }
+enum( struct vec3 ) Axis { Up @= { 1, 0, 0 }, Left @= { 0, 1, 0 }, Front @= { 0, 0, 1 } }
 \end{cfa}
 Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
@@ -2279 +2279 @@
 \Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
 \begin{cfa}
-enum( char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
-enum @/* inferred */@  Name3 { @inline Name2@, Sue = "Sue", Tom = "Tom" };
+enum( char * ) Name2 { ®inline Name®, Jack = "Jack", Jill = "Jill" };
+enum ®/* inferred */®  Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
 \end{cfa}
 Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
@@ -2353 +2353 @@
 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
 \begin{cfa}
-@[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) {
+®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
         $\emph{routine body}$
 }
@@ -2365 +2365 @@
 Declaration qualifiers can only appear at the start of a routine definition, \eg:
 \begin{cfa}
-@extern@ [ int x ] g( int y ) {$\,$}
+®extern® [ int x ] g( int y ) {$\,$}
 \end{cfa}
 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
@@ -2423 +2423 @@
 \begin{minipage}{\linewidth}
 \begin{cfa}
-@[ int x, int y ]@ f() {
+®[ int x, int y ]® f() {
         int z;
         ... x = 0; ... y = z; ...
-        @return;@ $\C{// implicitly return x, y}$
+        ®return;® $\C{// implicitly return x, y}$
 }
 \end{cfa}
@@ -2758 +2758 @@
 
 int fred() {
-        s.t.c = @S.@R;  // type qualification
-        struct @S.@T t = { @S.@R, 1, 2 };
-        enum @S.@C c;
-        union @S.T.@U u;
+        s.t.c = ®S.®R;  // type qualification
+        struct ®S.®T t = { ®S.®R, 1, 2 };
+        enum ®S.®C c;
+        union ®S.T.®U u;
 }
 \end{cfa}
@@ -2787 +2787 @@
 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
 {
-        @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$
+        ®int ?<?( int x, int y ) { return x > y; }® $\C{// nested routine}$
         qsort( ia, size ); $\C{// sort descending order by local redefinition}$
 }
@@ -2797 +2797 @@
 \begin{cfa}
 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$
-        int @i@ = 7;
+        int ®i® = 7;
         int bar( int p ) {
-                @i@ += 1; $\C{// dependent on local variable}$
-                sout | @i@;
+                ®i® += 1; $\C{// dependent on local variable}$
+                sout | ®i®;
         }
         return bar; $\C{// undefined because of local dependence}$
@@ -2818 +2818 @@
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 \begin{cfa}
-f( @2, x, 3 + i@ ); $\C{// element list}$
+f( ®2, x, 3 + i® ); $\C{// element list}$
 \end{cfa}
 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
@@ -2931 +2931 @@
 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
 \begin{cfa}
-[int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$
-printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$
+[int, int] ®qr® = div( 13, 5 ); $\C{// initialize tuple variable}$
+printf( "%d %d\n", ®qr® ); $\C{// print quotient/remainder}$
 \end{cfa}
 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
@@ -3596 +3596 @@
 \begin{cfa}
 int x = 1, y = 2, z = 3;
-sout | x @|@ y @|@ z;
+sout | x ®|® y ®|® z;
 \end{cfa}
 &
 \begin{cfa}
 
-cout << x @<< " "@ << y @<< " "@ << z << endl;
+cout << x ®<< " "® << y ®<< " "® << z << endl;
 \end{cfa}
 &
@@ -3610 +3610 @@
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-1@ @2@ @3
+1® ®2® ®3
 \end{cfa}
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-1@ @2@ @3
+1® ®2® ®3
 \end{cfa}
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-1@ @2@ @3
+1® ®2® ®3
 \end{cfa}
 \end{tabular}
 \end{cquote}
 The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators and newline.
-Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]@, @''.
+Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]{, }''.
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
@@ -3629 +3629 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1@, @2@, @3 4@, @5@, @6
+1®, ®2®, ®3 4®, ®5®, ®6
 \end{cfa}
 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
@@ -3638 +3638 @@
 &
 \begin{cfa}
-sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;
+sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
 \end{cfa}
 \\
@@ -3644 +3644 @@
 &
 \begin{cfa}
-cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@ << endl;
+cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
 \end{cfa}
 \\
@@ -3679 +3679 @@
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 
 
@@ -3685 +3685 @@
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 
 
@@ -3691 +3691 @@
 &
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@1@
-@2.5@
-@A@
+®1®
+®2.5®
+®A®
 \end{cfa}
 \end{tabular}
@@ -3729 +3729 @@
 
 \item
-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.
+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} is a closing citation mark.
 \begin{cfa}
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
@@ -3735 +3735 @@
 \end{cfa}
 \begin{cfa}[showspaces=true]
-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
+1®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9®)® x 10®]® x 11®}® x
 \end{cfa}
 
@@ -3742 +3742 @@
 %$
 \begin{cfa}
-sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
            | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
 \end{cfa}
 %$
 \begin{cfa}[showspaces=true]
-x @(@1 x @[@2 x @{@3 x @=@4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
+x ®(®1 x ®[®2 x ®{®3 x ®=®4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
 \end{cfa}
 %$
 
 \item
-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}
+A 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}
 \begin{cfa}
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
-x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@  @6@     @x
+x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
 \end{cfa}
 
@@ -3766 +3766 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
-x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4
+x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
 \end{cfa}
 \end{enumerate}
@@ -3779 +3779 @@
 \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
-\begin{cfa}[escapechar=off,belowskip=0pt]
-sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$
-sout | 1 | 2 | 3 | " \"" | @sep@ | "\"";
-\end{cfa}
-%$
-\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
-1@, $@2@, $@3 @", $"@
-\end{cfa}
-%$
+\begin{cfa}[belowskip=0pt]
+sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
+sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+1®, $\LstStringStyle{\textdollar}$®2®, $\LstStringStyle{\textdollar}$®3 ®", $\LstStringStyle{\textdollar}$"®
+\end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, " " ); $\C{// reset separator to " "}$
-sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@ | "\"";
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1@ @2@ @3 @" "@
+1® ®2® ®3 ®" "®
 \end{cfa}
 ©sepGet© can be used to store a separator and then restore it:
 \begin{cfa}[belowskip=0pt]
-char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$
+char store[®sepSize®]; $\C{// sepSize is the maximum separator size}$
 strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
 sepSet( sout, "_" ); $\C{// change separator to underscore}$
@@ -3803 +3801 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-1@_@2@_@3
+1®_®2®_®3
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
@@ -3810 +3808 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1@ @2@ @3
+1® ®2® ®3
 \end{cfa}
 
@@ -3818 +3816 @@
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
-sout | t1 | t2 | " \"" | @sepTuple@ | "\"";
+sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1 2 3 4 5 6 @" "@
+1 2 3 4 5 6 ®" "®
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
-sout | t1 | t2 | " \"" | @sepGetTuple( sout )@ | "\"";
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
-1, 2, 3 4, 5, 6 @", "@
+1, 2, 3 4, 5, 6 ®", "®
 \end{cfa}
 As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
@@ -3880 +3878 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@ @1 2 3@ @
+® ®1 2 3® ®
 \end{cfa}
 \end{enumerate}
@@ -3900 +3898 @@
 For example, in:
 \begin{cfa}
-sin | i | @nl@ | j;
-1 @2@
+sin | i | ®nl® | j;
+1 ®2®
 3
 \end{cfa}
@@ -3942 +3940 @@
 0b0 0b11011 0b11011 0b11011 0b11011
 sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
-0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101
+0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101
 \end{cfa}
 
@@ -3978 +3976 @@
 
 \item
+\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.
+\begin{cfa}[belowskip=0pt]
+sout | eng( 0.0 ) | eng( 27000.5 ) | eng( -27.5e7 );
+0®e0® 27.0005®e3® -275®e6®
+\end{cfa}
+
+\item
+\Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
+©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}$.
+For exponent $10^{0}$, no decimal point or letter is printed.
+\begin{cfa}[belowskip=0pt]
+sout | unit(eng( 0.0 )) | unit(eng( 27000.5 )) | unit(eng( -27.5e7 ));
+0 27.0005®K® -275®M®
+\end{cfa}
+
+\item
 \Indexc{upcase}( bin / hex / floating-point )\index{manipulator!upcase@©upcase©} print letters in a value in upper case. Lower case is the default.
 \begin{cfa}[belowskip=0pt]
 sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
-0@B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+4
+0®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
 \end{cfa}
 
@@ -3997 +4011 @@
 \begin{cfa}[belowskip=0pt]
 sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
-0.0 @0@ 27.0 @27@ 27.5
+0.0 ®0® 27.0 ®27® 27.5
 \end{cfa}
 
@@ -4004 +4018 @@
 \begin{cfa}[belowskip=0pt]
 sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
-@+@27 -27 @+@27.0 -27.0 @+@27.5 -27.5
-\end{cfa}
-
-\item
-\Indexc{wd}©( unsigned char minimum, T val )©\index{manipulator!wd@©wd©}, ©wd( unsigned char minimum, unsigned char precision, T val )©
-For all types, ©minimum© is the minimum number of printed characters.
+®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
+\end{cfa}
+
+\item
+\Indexc{wd}( minimum, value )\index{manipulator!wd@©wd©}, ©wd©( minimum, precision, value )
+For all types, minimum is the number of printed characters.
 If the value is shorter than the minimum, it is padded on the right with spaces.
 \begin{cfa}[belowskip=0pt]
@@ -4017 +4031 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@  @34 @ @34 34
-@  @4.000000 @ @4.000000 4.000000
-@  @ab @ @ab ab
-\end{cfa}
-If the value is larger, it is printed without truncation, ignoring the ©minimum©.
+®  ®34 ® ®34 34
+®  ®4.000000 ® ®4.000000 4.000000
+®  ®ab ® ®ab ab
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4, 34567 ) | wd( 3, 34567 ) | wd( 2, 34567 );
@@ -4028 +4042 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-3456@7@ 345@67@ 34@567@
-3456@.@ 345@6.@ 34@56.@
-abcd@e@ abc@de@ ab@cde@
-\end{cfa}
-
-For integer types, ©precision© is the minimum number of printed digits.
+3456®7® 345®67® 34®567®
+3456®.® 345®6.® 34®56.®
+abcd®e® abc®de® ab®cde®
+\end{cfa}
+
+For integer types, precision is the minimum number of printed digits.
 If the value is shorter, it is padded on the left with leading zeros.
 \begin{cfa}[belowskip=0pt]
@@ -4039 +4053 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
- @0@34     @00@34 @00000000@34
-\end{cfa}
-If the value is larger, it is printed without truncation, ignoring the ©precision©.
+ ®0®34     ®00®34 ®00000000®34
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the precision.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,1, 3456 ) | wd( 8,2, 3456 ) | wd( 10,3, 3456 );
@@ -4048 +4062 @@
 3456     3456       3456
 \end{cfa}
-If ©precision© is 0, nothing is printed for zero.
-If ©precision© is greater than the minimum, it becomes the minimum.
+If precision is 0, nothing is printed for zero.
+If precision is greater than the minimum, it becomes the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,0, 0 ) | wd( 3,10, 34 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@    @ @00000000@34
-\end{cfa}
-For floating-point types, ©precision© is the minimum number of digits after the decimal point.
+®    ® ®00000000®34
+\end{cfa}
+For floating-point types, precision is the minimum number of digits after the decimal point.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,3, 27.5 ) | wd( 8,1, 27.5 ) | wd( 8,0, 27.5 ) | wd( 3,8, 27.5 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-27.@500@     27.@5@      28. 27.@50000000@
-\end{cfa}
-For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
+27.®500®     27.®5®      28. 27.®50000000®
+\end{cfa}
+For the C-string type, precision is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
@@ -4072 +4086 @@
 
 \item
-\Indexc{ws( unsigned char minimum, unsigned char significant, floating-point )}\index{manipulator!ws@©ws©}
-For floating-point type, ©minimum© is the same as for manipulator ©wd©, but ©significant© is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
-If a value's significant digits is greater than ©significant©, the last significant digit is rounded up.
+\begin{sloppypar}
+\Indexc{ws}( minimum, significant, floating-point )\index{manipulator!ws@©ws©}
+For 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©).
+If a value's significant digits is greater than significant, the last significant digit is rounded up.
+\end{sloppypar}
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234.567) | ws(6,5, 234.567) | ws(6,4, 234.567) | ws(6,3, 234.567);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-234.567 234.5@7@  234.@6@    23@5@
-\end{cfa}
-If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
+234.567 234.5®7®  234.®6®    23®5®
+\end{cfa}
+If a value's magnitude is greater than significant, the value is printed in scientific notation with the specified number of significant digits.
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234567.) | ws(6,5, 234567.) | ws(6,4, 234567.) | ws(6,3, 234567.);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-234567. 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@
-\end{cfa}
-If ©significant© is greater than ©minimum©, it defines the number of printed characters.
+234567. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
+\end{cfa}
+If significant is greater than minimum, it defines the number of printed characters.
 \begin{cfa}[belowskip=0pt]
 sout | ws(3,6, 234567.) | ws(4,6, 234567.) | ws(5,6, 234567.) | ws(6,6, 234567.);
@@ -4102 +4118 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-27@  @ 27.000000  27.500000  027  27.500@    @
+27®  ® 27.000000  27.500000  027  27.500®    ®
 \end{cfa}
 
@@ -4109 +4125 @@
 \begin{cfa}[belowskip=0pt]
 sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
-@00@27  @0@27 @00@27.500
+®00®27  ®0®27 ®00®27.500
 \end{cfa}
 \end{enumerate}
@@ -4194 +4210 @@
 \begin{enumerate}
 \item
-\Indexc{skip( const char * pattern )}\index{manipulator!skip@©skip©} / ©skip( unsigned int length )© / ©const char * pattern©
-The argument defines a ©pattern© or ©length©.
-The ©pattern© is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
-The ©length© is composed of the next $N$ characters, including the newline character.
+\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length )
+The pattern is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The length is composed of the next $N$ characters, including the newline character.
 If the match successes, the input characters are discarded, and input continues with the next character.
 If the match fails, the input characters are left unread.
@@ -4205 +4220 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@abc   @
-@abc  @
-@xx@
-\end{cfa}
-
-\item
-\Indexc{wdi}©( unsigned int maximum, T & val )©\index{manipulator!wdi@©wdi©}
-For all types except ©char©, ©maximum© is the maximum number of characters read for the current operation.
+®abc   ®
+®abc  ®
+®xx®
+\end{cfa}
+
+\item
+\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©}
+For all types except ©char©, maximum is the maximum number of characters read for the current operation.
 \begin{cfa}[belowskip=0pt]
 char s[10];   int i;   double d;   
@@ -4218 +4233 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@abcd1233.456E+2@
+®abcd1233.456E+2®
 \end{cfa}
 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
@@ -4224 +4239 @@
 
 \item
-\Indexc{ignore( T & val )}\index{manipulator!ignore@©ignore©}
+\Indexc{ignore}( reference-value )\index{manipulator!ignore@©ignore©}
 For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
 \begin{cfa}[belowskip=0pt]
@@ -4231 +4246 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@  -75.35e-4@ 25
-\end{cfa}
-
-\item
-\Indexc{incl( const char * scanset, char * s )}\index{manipulator!incl@©incl©}
-For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{in} the set.
-Matching characters are read into the C string and null terminated.
+®  -75.35e-4® 25
+\end{cfa}
+
+\item
+\Indexc{incl}( scanset, input-string )\index{manipulator!incl@©incl©}
+For C-string types, the scanset matches any number of characters \emph{in} the set.
+Matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
@@ -4243 +4258 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@bca@xyz
-\end{cfa}
-
-\item
-\Indexc{excl( const char * scanset, char * s )}\index{manipulator!excl@©excl©}
-For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{not in} the set.
-Non-matching characters are read into the C string and null terminated.
+®bca®xyz
+\end{cfa}
+
+\item
+\Indexc{excl}( scanset, input-string )\index{manipulator!excl@©excl©}
+For C-string types, the scanset matches any number of characters \emph{not in} the set.
+Non-matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
@@ -4255 +4270 @@
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
-@xyz@bca
+®xyz®bca
 \end{cfa}
 \end{enumerate}
@@ -4306 +4321 @@
 The 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:
 \begin{cfa}
-$\emph{thread\(_1\)}$ : sout | @acquire@ | "abc " | "def ";   // manipulator
-$\emph{thread\(_2\)}$ : sout | @acquire@ | "uvw " | "xyz ";
+$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
+$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
 \end{cfa}
 Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
@@ -4329 +4344 @@
 \begin{cfa}
 {       // acquire sout for block duration
-        @osacquire@ acq = { sout };                             $\C{// named stream locker}$
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
         sout | 1;
-        sout | @acquire@ | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
+        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
         sout | 4;
 }       // implicitly release the lock when "acq" is deallocated
@@ -4341 +4356 @@
 \begin{cfa}
 {       // acquire sin lock for block duration
-        @isacquire acq = { sin };@                              $\C{// named stream locker}$
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
         int x, y, z, w;
         sin | x;
-        sin | @acquire@ | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
+        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
         sin | w;
 }       // implicitly release the lock when "acq" is deallocated
@@ -4353 +4368 @@
 \Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
 \begin{cfa}
-sout | @acquire@ | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
+sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
 \end{cfa}
 If 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.
@@ -4359 +4374 @@
 To prevent nested locking, a simple precaution is to factor out the blocking call from the expression, \eg:
 \begin{cfa}
-int @data@ = rtn( mon );
-sout | acquire | "data:" | @data@;
+int ®data® = rtn( mon );
+sout | acquire | "data:" | ®data®;
 \end{cfa}
 
@@ -4809 +4824 @@
 For example, given
 \begin{cfa}
-auto j = @...@
+auto j = ®...®
 \end{cfa}
 and the need to write a routine to compute using ©j©
 \begin{cfa}
-void rtn( @...@ parm );
+void rtn( ®...® parm );
 rtn( j );
 \end{cfa}
@@ -5051 +5066 @@
 \begin{cfa}
 #include <fstream.hfa>
-#include @<coroutine.hfa>@
-
-@coroutine@ Fibonacci {
+#include ®<coroutine.hfa>®
+
+®coroutine® Fibonacci {
         int fn; $\C{// used for communication}$
 };
@@ -5060 +5075 @@
         int fn1, fn2; $\C{// retained between resumes}$
         fn = 0;  fn1 = fn; $\C{// 1st case}$
-        @suspend;@ $\C{// restart last resume}$
+        ®suspend;® $\C{// restart last resume}$
         fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
-        @suspend;@ $\C{// restart last resume}$
+        ®suspend;® $\C{// restart last resume}$
         for () {
                 fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
-                @suspend;@ $\C{// restart last resume}$
+                ®suspend;® $\C{// restart last resume}$
         }
 }
 int next( Fibonacci & fib ) with( fib ) {
-        @resume( fib );@ $\C{// restart last suspend}$
+        ®resume( fib );® $\C{// restart last suspend}$
         return fn;
 }
@@ -5106 +5121 @@
 \begin{cfa}
 #include <fstream.hfa>
-#include @<thread.hfa>@
-
-@monitor@ AtomicCnt { int counter; };
+#include ®<thread.hfa>®
+
+®monitor® AtomicCnt { int counter; };
 void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
-int inc( AtomicCnt & @mutex@ c, int inc = 1 ) with(c) { return counter += inc; }
-int dec( AtomicCnt & @mutex@ c, int dec = 1 ) with(c) { return counter -= dec; }
+int inc( AtomicCnt & ®mutex® c, int inc = 1 ) with(c) { return counter += inc; }
+int dec( AtomicCnt & ®mutex® c, int dec = 1 ) with(c) { return counter -= dec; }
 forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
         ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
@@ -6599 +6614 @@
 
 C has a number of syntax ambiguities, which are resolved by taking the longest sequence of overlapping characters that constitute a token.
-For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]@x ++ ++ + y@ because operator tokens ©++© and ©+© overlap.
-Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]@x ++ + ++ y@ might yield a correct expression.
+For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]{x ++ ++ + y} because operator tokens ©++© and ©+© overlap.
+Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]{x ++ + ++ y} might yield a correct expression.
 Hence, C programmers are aware that spaces have to added to disambiguate certain syntactic cases.
 
@@ -6620 +6635 @@
 requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
 However, the dereference operator \emph{must} have a parameter/argument to dereference ©*?(...)©.
-Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]@* ?()@ does not preclude any meaningful program.
+Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]{* ?()} does not preclude any meaningful program.
 
 The remaining cases are with the increment/decrement operators and conditional expression, \eg:
@@ -6728 +6743 @@
 \begin{cfa}
 int i; $\C{// forward definition}$
-int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$
+int *j = ®&i®; $\C{// forward reference, valid in C, invalid in \CFA}$
 int i = 0; $\C{// definition}$
 \end{cfa}
@@ -6736 +6751 @@
 struct X { int i; struct X *next; };
 static struct X a; $\C{// forward definition}$
-static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$
+static struct X b = { 0, ®&a® };$\C{// forward reference, valid in C, invalid in \CFA}$
 static struct X a = { 1, &b }; $\C{// definition}$
 \end{cfa}
@@ -6749 +6764 @@
 \item[Change:] have ©struct© introduce a scope for nested types:
 \begin{cfa}
-enum @Colour@ { R, G, B, Y, C, M };
+enum ®Colour® { R, G, B, Y, C, M };
 struct Person {
-        enum @Colour@ { R, G, B };      $\C[7cm]{// nested type}$
+        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
         struct Face { $\C{// nested type}$
-                @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$
+                ®Colour® Eyes, Hair; $\C{// type defined outside (1 level)}$
         };
-        @.Colour@ shirt; $\C{// type defined outside (top level)}$
-        @Colour@ pants; $\C{// type defined same level}$
+        ®.Colour® shirt; $\C{// type defined outside (top level)}$
+        ®Colour® pants; $\C{// type defined same level}$
         Face looks[10]; $\C{// type defined same level}$
 };
-@Colour@ c = R; $\C{// type/enum defined same level}$
-Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$
-Person@.@Face pretty; $\C{// type defined inside}\CRT$
+®Colour® c = R; $\C{// type/enum defined same level}$
+Person®.Colour® pc = Person®.®R;$\C{// type/enum defined inside}$
+Person®.®Face pretty; $\C{// type defined inside}\CRT$
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
@@ -7064 +7079 @@
 // assume ?|? operator for printing an S
 
-S & sp = *@new@( 3 );                                                   $\C{// call constructor after allocation}$
+S & sp = *®new®( 3 );                                                   $\C{// call constructor after allocation}$
 sout | sp.i;
-@delete@( &sp );
-
-S * spa = @anew@( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
+®delete®( &sp );
+
+S * spa = ®anew®( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
 for ( i; 10 ) sout | spa[i] | nonl;
 sout | nl;
-@adelete@( 10, spa );
+®adelete®( 10, spa );
 \end{cfa}
 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
@@ -7683 +7698 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
+%\subsection{\texorpdfstring{\protect\lstinline{Duration}}{Duration}}
 \subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}}
 \label{s:Duration}
@@ -7777 +7792 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
+%\subsection{\texorpdfstring{\protect\lstinline{timeval}}{timeval}}
 \subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}}
 \label{s:timeval}
@@ -7797 +7812 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+%\subsection{\texorpdfstring{\protect\lstinline{timespec}}{timespec}}
 \subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}}
 \label{s:timespec}
@@ -7817 +7832 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+%\subsection{\texorpdfstring{\protect\lstinline{itimerval}}{itimerval}}
 \subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}}
 \label{s:itimerval}
@@ -7828 +7843 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+%\subsection{\texorpdfstring{\protect\lstinline{Time}}{Time}}
 \subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}}
 \label{s:Time}
@@ -7894 +7909 @@
 
 
-%\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
+%\subsection{\texorpdfstring{\protect\lstinline{Clock}}{Clock}}
 \subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}}
 \label{s:Clock}
@@ -8115 +8130 @@
 #include <gmp.h>$\indexc{gmp.h}$
 int main( void ) {
-        @gmp_printf@( "Factorial Numbers\n" );
-        @mpz_t@ fact;
-        @mpz_init_set_ui@( fact, 1 );
-        @gmp_printf@( "%d %Zd\n", 0, fact );
+        ®gmp_printf®( "Factorial Numbers\n" );
+        ®mpz_t® fact;
+        ®mpz_init_set_ui®( fact, 1 );
+        ®gmp_printf®( "%d %Zd\n", 0, fact );
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
-                @mpz_mul_ui@( fact, fact, i );
-                @gmp_printf@( "%d %Zd\n", i, fact );
+                ®mpz_mul_ui®( fact, fact, i );
+                ®gmp_printf®( "%d %Zd\n", i, fact );
         }
 }

libcfa/src/concurrency/coroutine.cfa

@@ -61 +61 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-                T & cor, $coroutine * desc, _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable ) {
+                T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
         verify( desc->cancellation );
         desc->state = Cancelled;
@@ -145 +145 @@
 // Part of the Public API
 // Not inline since only ever called once per coroutine
-forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T& cor) {
         $coroutine* this = get_coroutine(cor);

libcfa/src/concurrency/coroutine.hfa

@@ -60 +60 @@
 //-----------------------------------------------------------------------------
 // Public coroutine API
-forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T & cor);
 
@@ -131 +131 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-        T & cor, $coroutine * desc, _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable );
+        T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
 
 // Resume implementation inlined for performance
-forall(T & | is_coroutine(T) | { _EHM_VTABLE_TYPE(CoroutineCancelled)(T) & const _default_vtable; })
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 static inline T & resume(T & cor) {
         // optimization : read TLS once and reuse it

libcfa/src/concurrency/stats.cfa

@@ -126 +126 @@
 
                 char buf[1024];
-                strstream sstr = { buf, 1024 };
+                ostrstream sstr = { buf, 1024 };
 
                 if( flags & CFA_STATS_READY_Q ) {

libcfa/src/concurrency/thread.cfa

@@ -82 +82 @@
 
 forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
-    | { _EHM_VTABLE_TYPE(ThreadCancelled)(T) & const _default_vtable; })
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 void ?{}( thread_dtor_guard_t & this,
                 T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
@@ -161 +161 @@
 //-----------------------------------------------------------------------------
 forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
-    | { _EHM_VTABLE_TYPE(ThreadCancelled)(T) & const _default_vtable; })
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 T & join( T & this ) {
         thread_dtor_guard_t guard = { this, defaultResumptionHandler };

libcfa/src/concurrency/thread.hfa

@@ -80 +80 @@
 
 forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
-    | { _EHM_VTABLE_TYPE(ThreadCancelled)(T) & const _default_vtable; } )
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );
@@ -127 +127 @@
 // join
 forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
-    | { _EHM_VTABLE_TYPE(ThreadCancelled)(T) & const _default_vtable; } )
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 T & join( T & this );
 

libcfa/src/exception.hfa

@@ -64 +64 @@
         _EHM_VIRTUAL_TABLE(exception_name, arguments, table_name)
 
-#define EHM_TYPE_ID(exception_name) _EHM_TYPE_ID_TYPE(exception_name)
-
-#define EHM_MATCH_ALL __cfa__parent_vtable
+// EHM_DEFAULT_VTABLE(exception_name, (arguments))
+// Create a declaration for a (possibly polymorphic) default vtable.
+#define EHM_DEFAULT_VTABLE(exception_name, arguments) \
+        _EHM_VTABLE_TYPE(exception_name) arguments & const _default_vtable
 
 // IS_EXCEPTION(exception_name [, (...parameters)])

libcfa/src/fstream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 09:05:16 2021
-// Update Count     : 426
-//
-
-#include "fstream.hfa"
+// Last Modified On : Tue Apr 27 22:08:57 2021
+// Update Count     : 442
+//
+
+#include "fstream.hfa"                                                                  // also includes iostream.hfa
 
 #include <stdio.h>                                                                              // vfprintf, vfscanf
@@ -196 +196 @@
 ofstream & abort = abortFile;
 
+ofstream & nl( ofstream & os ) {
+        nl$( os );                                                                                      // call basic_ostream nl
+        flush( os );
+        return os;
+        // (ofstream &)(os | '\n');
+        // setPrt$( os, false );                                                        // turn off
+        // setNL$( os, true );
+        // flush( os );
+        // return sepOff( os );                                                 // prepare for next line
+} // nl
 
 // *********************************** ifstream ***********************************

libcfa/src/fstream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 09:04:03 2021
-// Update Count     : 219
+// Last Modified On : Tue Apr 27 22:00:30 2021
+// Update Count     : 226
 //
 
@@ -71 +71 @@
 bool fail( ofstream & );
 int flush( ofstream & );
-void open( ofstream &, const char name[], const char mode[] );
+void open( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
 void open( ofstream &, const char name[] );
 void close( ofstream & );
@@ -86 +86 @@
 
 void ?{}( ofstream & );
-void ?{}( ofstream &, const char name[], const char mode[] );
+void ?{}( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
 void ?{}( ofstream &, const char name[] );
 void ^?{}( ofstream & );
+
+// private
+static inline ofstream & nl$( ofstream & os ) { return nl( os ); } // remember basic_ostream nl
+// public
+ofstream & nl( ofstream & os );                                                 // override basic_ostream nl
 
 extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
@@ -111 +116 @@
 bool getANL( ifstream & );
 void ends( ifstream & );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+
 bool fail( ifstream & is );
 int eof( ifstream & is );
-void open( ifstream & is, const char name[], const char mode[] );
+void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
 void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
 ifstream & ungetc( ifstream & is, char c );
-int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+
 void acquire( ifstream & is );
 void release( ifstream & is );
@@ -129 +136 @@
 
 void ?{}( ifstream & is );
-void ?{}( ifstream & is, const char name[], const char mode[] );
+void ?{}( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
 void ?{}( ifstream & is, const char name[] );
 void ^?{}( ifstream & is );

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 10:03:54 2021
-// Update Count     : 1329
+// Last Modified On : Tue Apr 27 18:01:03 2021
+// Update Count     : 1330
 //
 
@@ -145 +145 @@
         } // ?|?
 
-#if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         //      UINT64_MAX 18_446_744_073_709_551_615_ULL
         #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
 
         static inline void base10_128( ostype & os, unsigned int128 val ) {
-#if defined(__GNUC__) && __GNUC_PREREQ(7,0)                             // gcc version >= 7
+                #if defined(__GNUC__) && __GNUC_PREREQ(7,0)             // gcc version >= 7
                 if ( val > P10_UINT64 ) {
-#else
+                #else
                 if ( (uint64_t)(val >> 64) != 0 || (uint64_t)val > P10_UINT64 ) { // patch gcc 5 & 6 -O3 bug
-#endif // __GNUC_PREREQ(7,0)
+                #endif // __GNUC_PREREQ(7,0)
                         base10_128( os, val / P10_UINT64 );                     // recursive
                         fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
@@ -187 +187 @@
                 (ostype &)(os | ullli); ends( os );
         } // ?|?
-#endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
 
         #define PrintWithDP( os, format, val, ... ) \
@@ -361 +361 @@
                 setPrt$( os, false );                                                   // turn off
                 setNL$( os, true );
-                flush( os );
                 return sepOff( os );                                                    // prepare for next line
         } // nl
@@ -808 +807 @@
 
 
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, bool & b ) {
                 char val[6];
@@ -918 +917 @@
         } // ?|?
 
-#if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         istype & ?|?( istype & is, int128 & llli ) {
                 return (istype &)(is | (unsigned int128 &)llli);
@@ -944 +943 @@
                 (istype &)(is | ullli); ends( is );
         } // ?|?
-#endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
 
         istype & ?|?( istype & is, float & f ) {
@@ -1035 +1034 @@
                 return is;
         } // nlOff
-
+} // distribution
+
+forall( istype & | istream( istype ) ) {
         istype & acquire( istype & is ) {
                 acquire( is );                                                                  // call void returning
@@ -1044 +1045 @@
 // *********************************** manipulators ***********************************
 
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, _Istream_Cstr f ) {
                 // skip xxx
@@ -1092 +1093 @@
 
 #define InputFMTImpl( T, CODE ) \
-forall( istype & | istream( istype ) ) { \
+forall( istype & | basic_istream( istype ) ) { \
         istype & ?|?( istype & is, _Istream_Manip(T) f ) { \
                 enum { size = 16 }; \
@@ -1125 +1126 @@
 InputFMTImpl( long double, "Lf" )
 
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, _Istream_Manip(float _Complex) fc ) {
                 float re, im;

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 09:28:56 2021
-// Update Count     : 393
+// Last Modified On : Tue Apr 27 17:59:21 2021
+// Update Count     : 398
 //
 
@@ -49 +49 @@
         void ends( ostype & );                                                          // end of output statement
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
-        int flush( ostype & );
 }; // basic_ostream
         
 trait ostream( ostype & | basic_ostream( ostype ) ) {
+        int flush( ostype & );
         bool fail( ostype & );                                                          // operation failed?
         void open( ostype &, const char name[], const char mode[] );
@@ -97 +97 @@
         ostype & ?|?( ostype &, unsigned long long int );
         void ?|?( ostype &, unsigned long long int );
-#if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         ostype & ?|?( ostype &, int128 );
         void ?|?( ostype &, int128 );
         ostype & ?|?( ostype &, unsigned int128 );
         void ?|?( ostype &, unsigned int128 );
-#endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
 
         ostype & ?|?( ostype &, float );
@@ -121 +121 @@
         void ?|?( ostype &, const char [] );
         // ostype & ?|?( ostype &, const char16_t * );
-#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
+        #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
         // ostype & ?|?( ostype &, const char32_t * );
-#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
+        #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
         // ostype & ?|?( ostype &, const wchar_t * );
         ostype & ?|?( ostype &, const void * );
@@ -164 +164 @@
 struct _Ostream_Manip {
         T val;                                                                                          // polymorphic base-type
-        int wd, pc;                                                                                     // width, precision
+        int wd, pc;                                                                                     // width, precision: signed for computations
         char base;                                                                                      // numeric base / floating-point style
         union {
@@ -192 +192 @@
         _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'x', { .all : 0 } }; } \
         _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, CODE, { .all : 0 } }; } \
-        _Ostream_Manip(T) wd( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
         _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
-        _Ostream_Manip(T) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
         _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
         _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \
@@ -231 +231 @@
         _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.eng : true } }; } \
         _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'g', { .all : 0 } }; } \
-        _Ostream_Manip(T) wd( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
-        _Ostream_Manip(T) ws( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) ws( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
         _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; return fmt; } \
-        _Ostream_Manip(T) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
-        _Ostream_Manip(T) & ws( unsigned int w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & ws( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
         _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
         _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'G', { .all : 0 } }; } \
@@ -279 +279 @@
         _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
-        _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, unsigned int pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
         _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
-        _Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
+        _Ostream_Manip(const char *) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
         _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; }
         _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
@@ -294 +294 @@
 
 
-trait istream( istype & ) {
+trait basic_istream( istype & ) {
+        bool getANL( istype & );                                                        // get scan newline (on/off)
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
-        bool getANL( istype & );                                                        // get scan newline (on/off)
 
         void ends( istype & os );                                                       // end of output statement
+        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+        istype & ungetc( istype &, char );
+        int eof( istype & );
+}; // basic_istream
+
+trait istream( istype & | basic_istream( istype ) ) {
         bool fail( istype & );
-        int eof( istype & );
         void open( istype & is, const char name[] );
         void close( istype & is );
         istype & read( istype &, char *, size_t );
-        istype & ungetc( istype &, char );
-        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
-        void acquire( istype & );
+        void acquire( istype & );                                                       // concurrent access
 }; // istream
 
@@ -314 +317 @@
 }; // readable
 
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype &, bool & );
         void ?|?( istype &, bool & );
@@ -341 +344 @@
         istype & ?|?( istype &, unsigned long long int & );
         void ?|?( istype &, unsigned long long int & );
-#if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         istype & ?|?( istype &, int128 & );
         void ?|?( istype &, int128 & );
         istype & ?|?( istype &, unsigned int128 & );
         void ?|?( istype &, unsigned int128 & );
-#endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
 
         istype & ?|?( istype &, float & );
@@ -372 +375 @@
         istype & nlOn( istype & );
         istype & nlOff( istype & );
+} // distribution
+
+forall( istype & | istream( istype ) ) {
         istype & acquire( istype & );
 } // distribution
@@ -391 +397 @@
 
 static inline {
+        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
-        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
         _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
@@ -402 +408 @@
         _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
 } // distribution
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, _Istream_Cstr f );
         void ?|?( istype & is, _Istream_Cstr f );
@@ -415 +421 @@
         _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; }
 } // distribution
-forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, _Istream_Char f );
         void ?|?( istype & is, _Istream_Char f );
@@ -434 +440 @@
         _Istream_Manip(T) & wdi( unsigned int w, _Istream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
 } /* distribution */ \
-forall( istype & | istream( istype ) ) { \
+forall( istype & | basic_istream( istype ) ) { \
         istype & ?|?( istype & is, _Istream_Manip(T) f ); \
         void ?|?( istype & is, _Istream_Manip(T) f ); \

libcfa/src/strstream.cfa

@@ -10 +10 @@
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 11:15:47 2021
-// Update Count     : 73
+// Last Modified On : Tue Apr 27 20:59:53 2021
+// Update Count     : 78
 // 
 
@@ -23 +23 @@
 #include <unistd.h>                                                                             // sbrk, sysconf
 
+
 // *********************************** strstream ***********************************
 
@@ -29 +30 @@
 
 // private
-bool sepPrt$( strstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
-void sepReset$( strstream & os ) { os.sepOnOff$ = os.sepDefault$; }
-void sepReset$( strstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
-const char * sepGetCur$( strstream & os ) { return os.sepCur$; }
-void sepSetCur$( strstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
-bool getNL$( strstream & os ) { return os.sawNL$; }
-void setNL$( strstream & os, bool state ) { os.sawNL$ = state; }
-bool getANL$( strstream & os ) { return os.nlOnOff$; }
-bool getPrt$( strstream & os ) { return os.prt$; }
-void setPrt$( strstream & os, bool state ) { os.prt$ = state; }
+bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
+void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ostrstream & os ) { return os.sawNL$; }
+void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ostrstream & os ) { return os.prt$; }
+void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 
 // public
-void ?{}( strstream & os, char buf[], size_t size ) {
+void ?{}( ostrstream & os, char buf[], size_t size ) {
         os.buf$ = buf;
         os.size$ = size;
@@ -55 +56 @@
 } // ?{}
 
-void sepOn( strstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
-void sepOff( strstream & os ) { os.sepOnOff$ = false; }
+void sepOn( ostrstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void sepOff( ostrstream & os ) { os.sepOnOff$ = false; }
 
-bool sepDisable( strstream & os ) {
+bool sepDisable( ostrstream & os ) {
         bool temp = os.sepDefault$;
         os.sepDefault$ = false;
@@ -65 +66 @@
 } // sepDisable
 
-bool sepEnable( strstream & os ) {
+bool sepEnable( ostrstream & os ) {
         bool temp = os.sepDefault$;
         os.sepDefault$ = true;
@@ -72 +73 @@
 } // sepEnable
 
-void nlOn( strstream & os ) { os.nlOnOff$ = true; }
-void nlOff( strstream & os ) { os.nlOnOff$ = false; }
+void nlOn( ostrstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ostrstream & os ) { os.nlOnOff$ = false; }
 
-const char * sepGet( strstream & os ) { return os.separator$; }
-void sepSet( strstream & os, const char s[] ) {
+const char * sepGet( ostrstream & os ) { return os.separator$; }
+void sepSet( ostrstream & os, const char s[] ) {
         assert( s );
-        strncpy( os.separator$, s, strstream_sepSize - 1 );
-        os.separator$[strstream_sepSize - 1] = '\0';
+        strncpy( os.separator$, s, ostrstream_sepSize - 1 );
+        os.separator$[ostrstream_sepSize - 1] = '\0';
 } // sepSet
 
-const char * sepGetTuple( strstream & os ) { return os.tupleSeparator$; }
-void sepSetTuple( strstream & os, const char s[] ) {
+const char * sepGetTuple( ostrstream & os ) { return os.tupleSeparator$; }
+void sepSetTuple( ostrstream & os, const char s[] ) {
         assert( s );
-        strncpy( os.tupleSeparator$, s, strstream_sepSize - 1 );
-        os.tupleSeparator$[strstream_sepSize - 1] = '\0';
+        strncpy( os.tupleSeparator$, s, ostrstream_sepSize - 1 );
+        os.tupleSeparator$[ostrstream_sepSize - 1] = '\0';
 } // sepSet
 
-void ends( strstream & os ) {
+void ends( ostrstream & os ) {
         if ( getANL$( os ) ) nl( os );
         else setPrt$( os, false );                                                      // turn off
 } // ends
 
-int fmt( strstream & os, const char format[], ... ) {
+int fmt( ostrstream & os, const char format[], ... ) {
         va_list args;
         va_start( args, format );
         int len = vsnprintf( os.buf$ + os.cursor$, os.size$ - os.cursor$, format, args );
+        va_end( args );
         os.cursor$ += len;
         if ( os.cursor$ >= os.size$ ) {                                         // cursor exceeded buffer size?
-                #define fmtmsg IO_MSG "strstream truncated write, buffer too small.\n"
+                #define fmtmsg IO_MSG "ostrstream truncated write, buffer too small.\n"
                 write( STDERR_FILENO, fmtmsg, sizeof(fmtmsg) - 1 );
                 abort();
         } // if
-        va_end( args );
 
         setPrt$( os, true );                                                            // called in output cascade
@@ -111 +112 @@
 } // fmt
 
-int flush( strstream & ) {                                                              // match trait, not used
-        return 0;
-} // flush
-
-strstream & write( strstream & os ) {
-        return write( os, stdout );
-} // write
-strstream & write( strstream & os, FILE * stream ) {
+ostrstream & write( ostrstream & os, FILE * stream ) {
         if ( fwrite( os.buf$, 1, os.cursor$, stream ) != os.cursor$ ) {
-                #define writemsg IO_MSG "strstream write error.\n"
-                write( STDERR_FILENO, writemsg, sizeof(writemsg) - 1 );
+                #define ostrwritemsg IO_MSG "ostrstream write error.\n"
+                write( STDERR_FILENO, ostrwritemsg, sizeof(ostrwritemsg) - 1 );
                 abort();
         } // if
@@ -127 +121 @@
 } // write
 
-strstream & sstr;
+ostrstream & write( ostrstream & os ) {
+        return write( os, stdout );
+} // write
+
+
+// *********************************** istrstream ***********************************
+
+
+// public
+void ?{}( istrstream & is, char buf[] ) {
+        is.buf$ = buf;
+        is.cursor$ = 0;
+        is.nlOnOff$ = false;
+} // ?{}
+
+bool getANL( istrstream & is ) { return is.nlOnOff$; }
+void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
+void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
+
+void ends( istrstream & is ) {
+} // ends
+
+int eof( istrstream & is ) {
+        return 0;
+} // eof
+
+istrstream &ungetc( istrstream & is, char c ) {
+        // if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
+        //      abort | IO_MSG "ungetc" | nl | strerror( errno );
+        // } // if
+        return is;
+} // ungetc
+
+int fmt( istrstream & is, const char format[], ... ) {
+        va_list args;
+        va_start( args, format );
+        // This does not work because vsscanf does not return buffer position.
+        int len = vsscanf( is.buf$ + is.cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                int j;
+                printf( "X %d%n\n", len, &j );
+        } // if
+        is.cursor$ += len;
+        return len;
+} // fmt
 
 // Local Variables: //

libcfa/src/strstream.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 24 11:17:33 2021
-// Update Count     : 37
+// Last Modified On : Tue Apr 27 20:58:50 2021
+// Update Count     : 41
 // 
 
@@ -20 +20 @@
 
 
-// *********************************** strstream ***********************************
+// *********************************** ostrstream ***********************************
 
 
-enum { strstream_sepSize = 16 };
-struct strstream {                                                                              // satisfied basic_ostream
+enum { ostrstream_sepSize = 16 };
+struct ostrstream {                                                                             // satisfied basic_ostream
         char * buf$;
         size_t size$;
@@ -34 +34 @@
         bool sawNL$;
         const char * sepCur$;
-        char separator$[strstream_sepSize];
-        char tupleSeparator$[strstream_sepSize];
-}; // strstream
+        char separator$[ostrstream_sepSize];
+        char tupleSeparator$[ostrstream_sepSize];
+}; // ostrstream
 
 // Satisfies basic_ostream
 
 // private
-bool sepPrt$( strstream & );
-void sepReset$( strstream & );
-void sepReset$( strstream &, bool );
-const char * sepGetCur$( strstream & );
-void sepSetCur$( strstream &, const char [] );
-bool getNL$( strstream & );
-void setNL$( strstream &, bool );
-bool getANL$( strstream & );
-bool getPrt$( strstream & );
-void setPrt$( strstream &, bool );
+bool sepPrt$( ostrstream & );
+void sepReset$( ostrstream & );
+void sepReset$( ostrstream &, bool );
+const char * sepGetCur$( ostrstream & );
+void sepSetCur$( ostrstream &, const char [] );
+bool getNL$( ostrstream & );
+void setNL$( ostrstream &, bool );
+bool getANL$( ostrstream & );
+bool getPrt$( ostrstream & );
+void setPrt$( ostrstream &, bool );
 
 // public
-void sepOn( strstream & );
-void sepOff( strstream & );
-bool sepDisable( strstream & );
-bool sepEnable( strstream & );
-void nlOn( strstream & );
-void nlOff( strstream & );
+void sepOn( ostrstream & );
+void sepOff( ostrstream & );
+bool sepDisable( ostrstream & );
+bool sepEnable( ostrstream & );
+void nlOn( ostrstream & );
+void nlOff( ostrstream & );
 
-const char * sepGet( strstream & );
-void sepSet( strstream &, const char [] );
-const char * sepGetTuple( strstream & );
-void sepSetTuple( strstream &, const char [] );
+const char * sepGet( ostrstream & );
+void sepSet( ostrstream &, const char [] );
+const char * sepGetTuple( ostrstream & );
+void sepSetTuple( ostrstream &, const char [] );
 
-void ends( strstream & );
-int fmt( strstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
-int flush( strstream & );
+void ends( ostrstream & );
+int fmt( ostrstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 
-strstream & write( strstream & os );                                    // use stdout, default value not working
-strstream & write( strstream & os, FILE * stream = stdout );
+ostrstream & write( ostrstream & os, FILE * stream ); // FIX ME: use default = stdout
+ostrstream & write( ostrstream & os );
 
-void ?{}( strstream &, char buf[], size_t size );
+void ?{}( ostrstream &, char buf[], size_t size );
 
-extern strstream & sstr;
+
+// *********************************** istrstream ***********************************
+
+
+struct istrstream {
+        char * buf$;
+        size_t cursor$;
+        bool nlOnOff$;
+}; // istrstream
+
+// Satisfies basic_istream
+
+// public
+bool getANL( istrstream & );
+void nlOn( istrstream & );
+void nlOff( istrstream & );
+void ends( istrstream & );
+int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+istrstream & ungetc( istrstream & is, char c );
+int eof( istrstream & is );
+
+void ?{}( istrstream & is, char buf[] );
 
 // Local Variables: //

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 14 18:13:44 2021
-// Update Count     : 4983
+// Last Modified On : Mon Apr 26 18:41:54 2021
+// Update Count     : 4990
 //
 
@@ -211 +211 @@
 } // forCtrl
 
-bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
+bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
 
 // https://www.gnu.org/software/bison/manual/bison.html#Location-Type
@@ -812 +812 @@
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+        | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
@@ -2128 +2130 @@
 aggregate_data:
         STRUCT vtable_opt
-                { yyy = true; $$ = AggregateDecl::Struct; }
+                { $$ = AggregateDecl::Struct; }
         | UNION
-                { yyy = true; $$ = AggregateDecl::Union; }
+                { $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
-                { yyy = true; $$ = AggregateDecl::Exception; }
+                { $$ = AggregateDecl::Exception; }
           //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
@@ -2138 +2140 @@
 aggregate_control:                                                                              // CFA
         MONITOR
-                { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | MUTEX STRUCT
-                { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | GENERATOR
-                { yyy = true; $$ = AggregateDecl::Generator; }
+                { $$ = AggregateDecl::Generator; }
         | MUTEX GENERATOR
                 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
-                { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { $$ = AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
                 { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
-                { yyy = true; $$ = AggregateDecl::Thread; }
+                { $$ = AggregateDecl::Thread; }
         | MUTEX THREAD
                 { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }

tests/io/io-acquire.cfa

@@ -10 +10 @@
 // Created On       : Mon Mar  1 18:40:09 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  2 12:06:35 2021
-// Update Count     : 17
+// Last Modified On : Tue Apr 27 11:49:34 2021
+// Update Count     : 18
 // 
 
@@ -43 +43 @@
         int a, b, c, d, e, f, g, h, i;
         for ( 100 ) {                                                                           // local protection
-                sin  | acquire | a | b | c | d | e | f | g | h | i;
+                sin | acquire | a | b | c | d | e | f | g | h | i;
         }
         {                                                                                                       // global protection (RAII)

tests/strstream.cfa

@@ -5 +5 @@
     enum { size = 256 };
     char buf[size];
-    strstream sstr = { buf, size };
+    ostrstream osstr = { buf, size };
     int i = 3, j = 5, k = 7;
     double x = 12345678.9, y = 98765.4321e-11;
 
-    sstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
-    write( sstr );
+    osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
+    write( osstr );
     printf( "%s", buf );
     sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
+
+    // char buf2[] = "12 14 15 3.5 7e4";
+    // istrstream isstr = { buf2 };
+    // isstr | i | j | k | x | y;
+    // sout | i | j | k | x | y;
 }