Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision dabc4280679ad2f187c6e16e478187bdae3a606f) +++ doc/user/user.tex (revision bbbd2c445b2101bd6d0003a567ec6ef306f5d96e) @@ -11,6 +11,6 @@ %% 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,5 +70,5 @@ \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,6 +82,6 @@ \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,5 +177,5 @@ 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,5 +186,5 @@ 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,5 +195,5 @@ int main() { int x = 0, y = 1, z = 2; - @cout< 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,58 +1090,58 @@ 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,27 +1158,27 @@ \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,27 +1190,27 @@ { - @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,5 +1241,5 @@ -%\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,11 +1256,11 @@ \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,7 +1285,7 @@ \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,12 +1295,12 @@ \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,13 +1312,13 @@ 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,6 +1339,6 @@ 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,5 +1373,5 @@ \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,6 +1386,6 @@ 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,6 +1470,6 @@ 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,13 +1487,13 @@ \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,9 +1507,9 @@ \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,10 +1520,10 @@ \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,7 +1661,7 @@ & \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,8 +1701,8 @@ \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,5 +1730,5 @@ \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,9 +1746,9 @@ 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,5 +1757,5 @@ 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,9 +1766,9 @@ 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,11 +1793,11 @@ 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,10 +1820,10 @@ \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,5 +1857,5 @@ \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,8 +1881,8 @@ 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,6 +1895,6 @@ 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,5 +1917,5 @@ 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,13 +1979,13 @@ \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,6 +1997,6 @@ \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,6 +2224,6 @@ \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,20 +2232,20 @@ \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,5 +2270,5 @@ 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,6 +2279,6 @@ \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,5 +2353,5 @@ 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,5 +2365,5 @@ 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,8 +2423,8 @@ \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,8 +2758,8 @@ 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,5 +2787,5 @@ qsort( ia, size ); $\C{// sort ascending order using builtin ? y; }@ $\C{// nested routine}$ + ®int ? y; }® $\C{// nested routine}$ qsort( ia, size ); $\C{// sort descending order by local redefinition}$ } @@ -2797,8 +2797,8 @@ \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,5 +2818,5 @@ 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,6 +2931,6 @@ 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,10 +3596,10 @@ \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,18 +3610,18 @@ \\ \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,5 +3629,5 @@ \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,5 +3638,5 @@ & \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,5 +3644,5 @@ & \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,5 +3679,5 @@ \\ \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -@1@ @2.5@ @A@ +®1® ®2.5® ®A® @@ -3685,5 +3685,5 @@ & \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -@1@ @2.5@ @A@ +®1® ®2.5® ®A® @@ -3691,7 +3691,7 @@ & \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -@1@ -@2.5@ -@A@ +®1® +®2.5® +®A® \end{cfa} \end{tabular} @@ -3729,5 +3729,5 @@ \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,5 +3735,5 @@ \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,20 +3742,20 @@ %$ \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,5 +3766,5 @@ \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,23 +3779,21 @@ \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,5 +3801,5 @@ \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -1@_@2@_@3 +1®_®2®_®3 \end{cfa} \begin{cfa}[belowskip=0pt] @@ -3810,5 +3808,5 @@ \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt] -1@ @2@ @3 +1® ®2® ®3 \end{cfa} @@ -3818,15 +3816,15 @@ \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,5 +3878,5 @@ \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -@ @1 2 3@ @ +® ®1 2 3® ® \end{cfa} \end{enumerate} @@ -3900,6 +3898,6 @@ For example, in: \begin{cfa} -sin | i | @nl@ | j; -1 @2@ +sin | i | ®nl® | j; +1 ®2® 3 \end{cfa} @@ -3942,5 +3940,5 @@ 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,8 +3976,24 @@ \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,5 +4011,5 @@ \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,10 +4018,10 @@ \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,9 +4031,9 @@ \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,10 +4042,10 @@ \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,7 +4053,7 @@ \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,20 +4062,20 @@ 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,21 +4086,23 @@ \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,5 +4118,5 @@ \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,5 +4125,5 @@ \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,8 +4210,7 @@ \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,12 +4220,12 @@ \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,5 +4233,5 @@ \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,5 +4239,5 @@ \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,11 +4246,11 @@ \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,11 +4258,11 @@ \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,5 +4270,5 @@ \end{cfa} \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt] -@xyz@bca +®xyz®bca \end{cfa} \end{enumerate} @@ -4306,6 +4321,6 @@ 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,7 +4344,7 @@ \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,8 +4356,8 @@ \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,5 +4368,5 @@ \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,6 +4374,6 @@ 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,9 +4824,9 @@ 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,7 +5066,7 @@ \begin{cfa} #include -#include @@ - -@coroutine@ Fibonacci { +#include ®® + +®coroutine® Fibonacci { int fn; $\C{// used for communication}$ }; @@ -5060,14 +5075,14 @@ 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,10 +5121,10 @@ \begin{cfa} #include -#include @@ - -@monitor@ AtomicCnt { int counter; }; +#include ®® + +®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,6 +6614,6 @@ 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,5 +6635,5 @@ 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,5 +6743,5 @@ \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,5 +6751,5 @@ 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,17 +6764,17 @@ \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,12 +7079,12 @@ // 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,5 +7698,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}} +%\subsection{\texorpdfstring{\protect\lstinline{Duration}}{Duration}} \subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}} \label{s:Duration} @@ -7777,5 +7792,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}} +%\subsection{\texorpdfstring{\protect\lstinline{timeval}}{timeval}} \subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}} \label{s:timeval} @@ -7797,5 +7812,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}} +%\subsection{\texorpdfstring{\protect\lstinline{timespec}}{timespec}} \subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}} \label{s:timespec} @@ -7817,5 +7832,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}} +%\subsection{\texorpdfstring{\protect\lstinline{itimerval}}{itimerval}} \subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}} \label{s:itimerval} @@ -7828,5 +7843,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}} +%\subsection{\texorpdfstring{\protect\lstinline{Time}}{Time}} \subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}} \label{s:Time} @@ -7894,5 +7909,5 @@ -%\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}} +%\subsection{\texorpdfstring{\protect\lstinline{Clock}}{Clock}} \subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}} \label{s:Clock} @@ -8115,11 +8130,11 @@ #include $\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 ); } }