Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 4e2a57ff981bba930d52f02c5216ff9e5b75d092) +++ doc/user/user.tex (revision cfcbd03a26bc8ebcb086a967f417e73b4dcd2ef6) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Thu Sep 28 22:40:52 2023 -%% Update Count : 5578 +%% Last Modified On : Sat Sep 30 22:46:19 2023 +%% Update Count : 5658 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -65,6 +65,6 @@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -\setlength{\gcolumnposn}{3in} \CFAStyle % use default CFA format-style +\setgcolumn{2.25in} %\lstset{language=CFA} % CFA default lnaguage \lstnewenvironment{C++}[1][] % use C++ style @@ -537,5 +537,5 @@ Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism: \begin{cfa} -int ®``®coroutine = 3; $\C{// make keyword an identifier}$ +int ®``®coroutine = 3; $\C{// make keyword an identifier}$ double ®``®forall = 3.5; \end{cfa} @@ -547,9 +547,9 @@ \begin{cfa} // include file uses the CFA keyword "with". -#if ! defined( with ) $\C{// nesting ?}$ -#define with ®``®with $\C{// make keyword an identifier}$ +#if ! defined( with ) $\C{// nesting ?}$ +#define with ®``®with $\C{// make keyword an identifier}$ #define __CFA_BFD_H__ #endif -$\R{\#include\_next} $ $\C{// must have internal check for multiple expansion}$ +$\R{\#include\_next} $ $\C{// must have internal check for multiple expansion}$ #if defined( with ) && defined( __CFA_BFD_H__ ) $\C{// reset only if set}$ #undef with @@ -566,13 +566,13 @@ 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}$ +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} @@ -604,10 +604,9 @@ There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types. -Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2). +Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication ($O(\log y)$ multiplies or shifting if the exponent is 2). Overflow for a large exponent or negative exponent returns zero. Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative. \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); +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} @@ -622,5 +621,5 @@ T ?®\®?( T ep, unsigned long int y ); \end{cfa} -The user type ©T© must define multiplication, one (©1©), and ©*©. +A user type ©T© must define multiplication, one (©1©), and ©*©. @@ -636,10 +635,10 @@ Declarations in the \Indexc{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()® ) ... $\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()® ) ... $\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}$ @@ -655,11 +654,20 @@ \label{s:caseClause} -C restricts the \Indexc{case} clause of a \Indexc{switch} statement to a single value. -For multiple ©case© clauses associated with the same statement, it is necessary to have multiple ©case© clauses rather than multiple values. +C restricts a \Indexc{case} clause in \Indexc{switch} statement to a single value. +For multiple ©case© clauses prefixing a statement within the ©switch© statement, it is necessary to have multiple ©case© clauses rather than multiple values. Requiring a ©case© clause for each value is not in the spirit of brevity normally associated with C. Therefore, the ©case© clause is extended with a list of values. \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}} \\ +\begin{cfa} +switch ( i ) { + case 1: case 3 : case 5: + ... + case 2: case 4 : case 6: + ... +} +\end{cfa} +& \begin{cfa} switch ( i ) { @@ -672,13 +680,4 @@ & \begin{cfa} -switch ( i ) { - case 1: case 3 : case 5: - ... - case 2: case 4 : case 6: - ... -} -\end{cfa} -& -\begin{cfa} // odd values @@ -690,15 +689,48 @@ \end{tabular} \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.} +In addition, subranges are allowed to specify case values. +\begin{cquote} +\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{\hspace{2em}}l@{}} +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{©gcc©}} \\ \begin{cfa} switch ( i ) { - case ®1~5:® $\C{// 1, 2, 3, 4, 5}$ + case 1: case 2: case 3: case 4: ... - case ®10~15:® $\C{// 10, 11, 12, 13, 14, 15}$ + case 10: case 11: case 12: case 13: ... } \end{cfa} -Lists of subranges are also allowed. +& +\begin{cfa} +switch ( i ) { + case ®1~4:® + ... + case ®10~13:® + ... +} +\end{cfa} +& +\begin{cfa} +switch ( i ) { + case 1$\R{\textvisiblespace}$®...®4: + ... + case 10$\R{\textvisiblespace}$®...®13: + ... +} +\end{cfa} +& +\begin{cfa} + +// 1, 2, 3, 4 + +// 10, 11, 12, 13 + + +\end{cfa} +\end{tabular} +\end{cquote} +While ©gcc© has the same range mechanism, it has an awkward syntax, ©2©\R{\textvisiblespace}©...42©, because a space is required after a number, otherwise the period is a decimal point. + +\CFA also allows lists of subranges. \begin{cfa} case ®1~5, 12~21, 35~42®: @@ -771,5 +803,5 @@ This situation is better handled by a list of case values \see{\VRef{s:caseClause}}. While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from most programming languages with a ©switch© statement. -Hence, default fall-through semantics results in a large number of programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through. +Hence, default fall-through semantics results in a many programming errors as programmers often \emph{forget} the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through. \item @@ -848,5 +880,5 @@ and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound. \end{itemize} -These observations put into perspective the \CFA changes to the ©switch©. +These observations put into perspective the \CFA changes to the ©switch© statement. \begin{enumerate} \item @@ -890,13 +922,13 @@ \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}$ } ... @@ -909,5 +941,5 @@ The \Indexc{fallthrough} clause may be non-terminating within a \Indexc{case} clause or have a target label to common code from multiple case clauses. -\begin{center} +\begin{cquote} \begin{tabular}{@{}lll@{}} \begin{cfa} @@ -959,5 +991,5 @@ \end{cfa} \end{tabular} -\end{center} +\end{cquote} The target label must be below the \Indexc{fallthrough} and may not be nested in a control structure, and the target label must be at the same or higher level as the containing \Indexc{case} clause and located at @@ -966,6 +998,6 @@ \begin{figure} -\begin{tabular}{@{}l@{\hspace{40pt}}|l@{}} -\multicolumn{1}{@{}c@{\hspace{40pt}}|}{loop control} & \multicolumn{1}{c@{}}{output} \\ +\begin{tabular}{@{}l@{\hspace{50pt}}|l@{}} +\multicolumn{1}{@{}c@{\hspace{50pt}}|}{loop control} & \multicolumn{1}{c@{}}{output} \\ \hline \begin{cfa} @@ -1085,7 +1117,7 @@ The \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-control allow an empty conditional, which implies a comparison value of ©1© (true). \begin{cfa} -while ( ®/*empty*/® ) $\C{// while ( true )}$ -for ( ®/*empty*/® ) $\C{// for ( ; true; )}$ -do ... while ( ®/*empty*/® ) $\C{// do ... while ( true )}$ +while ( ®/* empty */® ) $\C{// while ( true )}$ +for ( ®/* empty */® ) $\C{// for ( ; true; )}$ +do ... while ( ®/* empty */® ) $\C{// do ... while ( true )}$ \end{cfa} @@ -1117,7 +1149,7 @@ If no type is specified for the loop index, it is the type of the high value H (when the low value is implicit) or the low value L. \begin{cfa} -for ( ®5® ) $\C{// typeof(5) anonymous-index; 5 is high value}$ -for ( i; ®1.5® ~ 5.5 ) $\C{// typeof(1.5) i; 1.5 is low value}$ -for ( ®int i®; 0 ~ 10 ~ 2 ) $\C{// int i; type is explicit}$ +for ( ®5® ) $\C{// typeof(5) anonymous-index; 5 is high value}$ +for ( i; ®1.5® ~ 5.5 ) $\C{// typeof(1.5) i; 1.5 is low value}$ +for ( ®int i®; 0 ~ 10 ~ 2 ) $\C{// int i; type is explicit}$ \end{cfa} @@ -1127,37 +1159,37 @@ H is implicit up-to exclusive range [0,H\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 ©~=© H is implicit up-to inclusive range [0,H\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 L ©~©\index{~@©~©} H is explicit up-to exclusive range [L,H\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 L ©~=©\index{~=@©~=©} H is explicit up-to inclusive range [L,H\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 L ©-~©\index{-~@©-~©} H is explicit down-to exclusive range [H,L\R{)}, where L and H are implicitly interchanged to make the range down-to. \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 L ©-~=©\index{-~=@©-~=©} H is explicit down-to inclusive range [H,L\R{]}, where L and H are implicitly interchanged to make the range down-to. \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 ( i; 1 ~ ®@® ~ 2 ) $\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}$ -for ( i; 1 ~ 10 ~ ®@® ) $\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}$ -for ( i; 1 ~ ®@® ~ ®@® ) $\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}$ +for ( i; 1 ~ ®@® ~ 2 ) $\C{// for ( typeof(1) i = 1; \R{/* empty */}; i += 2 )}$ +for ( i; 1 ~ 10 ~ ®@® ) $\C{// for ( typeof(1) i = 1; i < 10; \R{/* empty */} )}$ +for ( i; 1 ~ ®@® ~ ®@® ) $\C{// for ( typeof(1) i = 1; /*empty*/; \R{/* empty */} )}$ \end{cfa} L cannot be elided for the up-to range, \lstinline{@ ~ 5}, and H for the down-to range, \lstinline{1 -~ @}, because then the loop index is uninitialized. @@ -1166,12 +1198,12 @@ ©:© means low another index. \begin{cfa} -for ( i; 5 ®:® j; 2 ~ 12 ~ 3 ) $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}$ +for ( i; 5 ®:® j; 2 ~ 12 ~ 3 ) $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}$ \end{cfa} \end{itemize} \R{Warning}: specifying the down-to range maybe unexpected because the loop control \emph{implicitly} switches the L and H values (and toggles the increment/decrement for I): \begin{cfa} -for ( i; 1 ~ 10 ) ${\C[1.5in]{// up range}$ -for ( i; 1 -~ 10 ) ${\C{// down range}$ -for ( i; ®10 -~ 1® ) ${\C{// \R{WRONG down range!}}\CRT}$ +for ( i; 1 ~ 10 ) ${\C{// up range}$ +for ( i; 1 -~ 10 ) ${\C{// down range}$ +for ( i; ®10 -~ 1® ) ${\C{// \R{WRONG down range!}}}$ \end{cfa} The reason for this semantics is that the range direction can be toggled by adding/removing the minus, ©'-'©, versus interchanging the L and H expressions, which has a greater chance of introducing errors. @@ -1190,7 +1222,6 @@ \begin{figure} -\centering \begin{lrbox}{\myboxA} -\begin{cfa}[tabsize=3] +\begin{cfa}[tabsize=4] ®Compound:® { ®Try:® try { @@ -1222,5 +1253,5 @@ \begin{lrbox}{\myboxB} -\begin{cfa}[tabsize=3] +\begin{cfa}[tabsize=4] { @@ -1251,9 +1282,9 @@ \end{lrbox} -\subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA} +\subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB} \hspace{3pt} \vrule \hspace{3pt} -\subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB} +\subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA} \caption{Multi-level Exit} \label{f:MultiLevelExit} @@ -1289,5 +1320,5 @@ int a[10]; \end{cfa} -\begin{tabular}{@{}lll@{}} +\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{3em}}l@{}} \begin{cfa} @@ -1330,7 +1361,11 @@ Grouping heterogeneous data into an \newterm{aggregate} (structure/union) is a common programming practice, and aggregates may be nested: \begin{cfa} -struct Person { $\C{// aggregate}$ - struct Name { char first[20], last[20]; } name $\C{// nesting}$ - struct Address { ... } address $\C{// nesting}$ +struct Person { $\C{// aggregate}$ + struct Name { $\C{// nesting}$ + char first[20], last[20]; + } name; + struct Address { $\C{// nesting}$ + ... + } address; int sex; }; @@ -1339,5 +1374,5 @@ \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. @@ -1354,7 +1389,7 @@ \begin{cfa} struct S { - struct $\R{\LstCommentStyle{/* unnamed */}}$ { int g, h; } __attribute__(( aligned(64) )); + struct $\R{\LstCommentStyle{/* unnamed */}}$ { int g, h; } __attribute__(( aligned(64) )); int tag; - union $\R{\LstCommentStyle{/* unnamed */}}$ { + union $\R{\LstCommentStyle{/* unnamed */}}$ { struct { char c1, c2; } __attribute__(( aligned(128) )); struct { int i1, i2; }; @@ -1370,6 +1405,6 @@ struct S { char ®c®; int ®i®; double ®d®; - void f( /* S * this */ ) { $\C{// implicit ``this'' parameter}$ - ®c®; ®i®; ®d®; $\C{// this->c; this->i; this->d;}$ + void f( /* S * this */ ) { $\C{// implicit ``this'' parameter}$ + ®c®; ®i®; ®d®; $\C{// this->c; this->i; this->d;}$ } } @@ -1379,12 +1414,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}$ + 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}$ + 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}$ } }; @@ -1396,13 +1431,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} @@ -1427,11 +1462,11 @@ struct R { int ®i®; int j; double ®m®; } r, w; with ( r, q ) { - j + k; $\C{// unambiguous, r.j + q.k}$ - m = 5.0; $\C{// unambiguous, q.m = 5.0}$ - m = 1; $\C{// unambiguous, r.m = 1}$ - int a = m; $\C{// unambiguous, a = r.i }$ - double b = m; $\C{// unambiguous, b = q.m}$ - int c = r.i + q.i; $\C{// disambiguate with qualification}$ - (double)m; $\C{// disambiguate with cast}$ + j + k; $\C{// unambiguous, r.j + q.k}$ + m = 5.0; $\C{// unambiguous, q.m = 5.0}$ + m = 1; $\C{// unambiguous, r.m = 1}$ + int a = m; $\C{// unambiguous, a = r.i }$ + double b = m; $\C{// unambiguous, b = q.m}$ + int c = r.i + q.i; $\C{// disambiguate with qualification}$ + (double)m; $\C{// disambiguate with cast}$ } \end{cfa} @@ -1441,7 +1476,7 @@ \begin{cfa} with ( r ) { - i; $\C{// unambiguous, r.i}$ + i; $\C{// unambiguous, r.i}$ with ( q ) { - i; $\C{// unambiguous, q.i}$ + i; $\C{// unambiguous, q.i}$ } } @@ -1450,6 +1485,6 @@ A cast can also be used to disambiguate among overload variables in a ©with© \emph{expression}: \begin{cfa} -with ( w ) { ... } $\C{// ambiguous, same name and no context}$ -with ( (Q)w ) { ... } $\C{// unambiguous, cast}$ +with ( w ) { ... } $\C{// ambiguous, same name and no context}$ +with ( (Q)w ) { ... } $\C{// unambiguous, cast}$ \end{cfa} Because there is no left-side in the ©with© expression to implicitly disambiguate between the ©w© variables, it is necessary to explicitly disambiguate by casting ©w© to type ©Q© or ©R©. @@ -1458,5 +1493,5 @@ \begin{cfa} void f( S & s, char c ) with ( s ) { - ®s.c = c;® i = 3; d = 5.5; $\C{// initialize fields}$ + ®s.c = c;® i = 3; d = 5.5; $\C{// initialize fields}$ } \end{cfa} @@ -1464,5 +1499,5 @@ To solve this problem, parameters \emph{not} explicitly opened are treated like an initialized aggregate: \begin{cfa} -struct Params { $\C{// s explicitly opened so S \& s elided}$ +struct Params { $\C{// s explicitly opened so S \& s elided}$ char c; } params; @@ -1483,4 +1518,23 @@ Transfer of control can be local, within a routine, or non-local, among routines. Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise. + +Currently, \CFA uses macros ©ExceptionDecl© and ©ExceptionInst© to declare and instantiate an exception. +\begin{cfa} +#include +®ExceptionDecl®( E, // must be global scope + ... // exception fields +); +try { + ... + if ( ... ) ®throwResume® ®ExceptionInst®( E, /* intialization */ ); + if ( ... ) ®throw® ®ExceptionInst®( E, /* intialization */ ); + ... +} ®catchResume®( E * ) { // must be pointer + ... +} catch( E * ) { + ... +} +\end{cfa} + \begin{cfa} exception_t E {}; $\C{// exception type}$ @@ -1491,5 +1545,5 @@ try { f(...); -} catch( E e ; $boolean-predicate$ ) { $\C{// termination handler}$ +} catch( E e ; $boolean-predicate$ ) { $\C{// termination handler}$ // recover and continue } catchResume( E e ; $boolean-predicate$ ) { $\C{// resumption handler}$ @@ -1503,4 +1557,21 @@ The ©catch© and ©catchResume© handlers may appear in any oder. However, the ©finally© clause must appear at the end of the ©try© statement. + + +\section{Non-local Exception} + +\begin{cfa} +void main() { + try { + _Enable { + ... resume(); ... + } + } ®catchResume®( E & ) { // should be reference + ... + } catch( E & ) { + ... + } +} +\end{cfa} @@ -1568,15 +1639,15 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} \\ +\begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}] +®int® #*# x1 #[5]#; +®int® #(*#x2#)[5]#; +#int (*#f®( int p )®#)[5]#; +\end{cfa} +& \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}] #[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]#; \end{cfa} \end{tabular} @@ -1588,11 +1659,11 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} \\ +\begin{cfa} +int ®*®x, ®*®y; +\end{cfa} +& \begin{cfa} ®*® int x, y; -\end{cfa} -& -\begin{cfa} -int ®*®x, ®*®y; \end{cfa} \end{tabular} @@ -1601,13 +1672,13 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} \\ +\begin{cfa} +int ®*®x, y; + +\end{cfa} +& \begin{cfa} ®*® int x; int y; -\end{cfa} -& -\begin{cfa} -int ®*®x, y; - \end{cfa} \end{tabular} @@ -1617,5 +1688,16 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}} \\ +\begin{cfa} +int z[ 5 ]; +char * w[ 5 ]; +double (* v)[ 5 ]; +struct s { + int f0:3; + int * f1; + int * f2[ 5 ] +}; +\end{cfa} +& \begin{cfa} [ 5 ] int z; @@ -1630,15 +1712,4 @@ & \begin{cfa} -int z[ 5 ]; -char * w[ 5 ]; -double (* v)[ 5 ]; -struct s { - int f0:3; - int * f1; - int * f2[ 5 ] -}; -\end{cfa} -& -\begin{cfa} // array of 5 integers // array of 5 pointers to char @@ -1656,13 +1727,13 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}} -\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}} \\ +\begin{cfa} +int const * const x; +const int (* const y)[ 5 ] +\end{cfa} +& \begin{cfa} const * const int x; const * [ 5 ] const int y; -\end{cfa} -& -\begin{cfa} -int const * const x; -const int (* const y)[ 5 ] \end{cfa} & @@ -1677,13 +1748,13 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}} \\ +\begin{cfa} +int extern x[ 5 ]; +const int static * y; +\end{cfa} +& \begin{cfa} extern [ 5 ] int x; static * const int y; -\end{cfa} -& -\begin{cfa} -int extern x[ 5 ]; -const int static * y; \end{cfa} & @@ -1698,13 +1769,13 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} \\ +\begin{cfa} +y = (int *)x; +i = sizeof(int * [ 5 ]); +\end{cfa} +& \begin{cfa} y = (* int)x; i = sizeof([ 5 ] * int); -\end{cfa} -& -\begin{cfa} -y = (int *)x; -i = sizeof(int * [ 5 ]); \end{cfa} \end{tabular} @@ -1901,13 +1972,13 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{3em}}l@{}} -\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\multicolumn{1}{c@{\hspace{3em}}}{\textbf{Cy}} & \multicolumn{1}{c}{\textbf{\CFA}} \\ +\begin{cfa} +const int * ®const® * ®const® ccp; + +\end{cfa} +& \begin{cfa} ®const® * ®const® * const int ccp; ®const® & ®const® & const int ccr; -\end{cfa} -& -\begin{cfa} -const int * ®const® * ®const® ccp; - \end{cfa} \end{tabular} @@ -2070,5 +2141,5 @@ \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 \&)}$ +f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}\CRT$ \end{cfa} Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost. @@ -8630,20 +8701,6 @@ \begin{cquote} \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}} -\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c@{}}{\textbf{C}} \\ +\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{C}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c@{}}{\textbf{\CFA}} \\ \hline -\begin{cfa} -#include $\indexc{gmp}$ -int main( void ) { - sout | "Factorial Numbers"; - Int fact = 1; - - sout | 0 | fact; - for ( i; 40 ) { - fact *= i; - sout | i | fact; - } -} -\end{cfa} -& \begin{cfa} #include $\indexc{gmp.h}$ @@ -8656,4 +8713,18 @@ ®mpz_mul_ui®( fact, fact, i ); ®gmp_printf®( "%d %Zd\n", i, fact ); + } +} +\end{cfa} +& +\begin{cfa} +#include $\indexc{gmp}$ +int main( void ) { + sout | "Factorial Numbers"; + Int fact = 1; + + sout | 0 | fact; + for ( i; 40 ) { + fact *= i; + sout | i | fact; } }