Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 53a6c2a24c63e4878fd4222e11fef110ba3ee85a) +++ doc/user/user.tex (revision e9bb0e5c355dba790bfbe4c3dafa61cde70ede52) @@ -11,6 +11,6 @@ %% Created On : Wed Apr 6 14:53:29 2016 %% Last Modified By : Peter A. Buhr -%% Last Modified On : Fri Jul 7 10:36:39 2017 -%% Update Count : 2547 +%% Last Modified On : Thu Jul 13 07:08:58 2017 +%% Update Count : 2673 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -57,4 +57,8 @@ \CFAStyle % use default CFA format-style +\lstnewenvironment{C++}[1][] +{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}} +{} + % inline code ©...© (copyright symbol) emacs: C-q M-) % red highlighting ®...® (registered trademark symbol) emacs: C-q M-. @@ -137,17 +141,19 @@ \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed as an evolutionary step forward for the C programming language. -The syntax of the \CFA language builds from C, and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers. +The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers. % Any language feature that is not described here can be assumed to be using the standard \Celeven syntax. -\CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving C performance. -Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible. +\CFA adds many modern programming-language features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance. +Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible. The primary new features include parametric-polymorphic routines and types, exceptions, concurrency, and modules. -One of the main design philosophies of \CFA is to ``describe not prescribe'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''. -Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming features. -A programmer is always free to reach back to C from \CFA for any reason, and in many cases, new \CFA features have a fallback to a C mechanism. -There is no notion or requirement for rewriting a legacy C program in \CFA; -instead, a programmer evolves an existing C program into \CFA by incrementally incorporating \CFA features. -New programs can be written in \CFA using a combination of C and \CFA features. -\Index*[C++]{\CC{}} had a similar goal 30 years ago, but currently has the disadvantages of multiple legacy design-choices that cannot be updated and active divergence of the language model from C, requiring significant effort and training to incrementally add \CC to a C-based project. +One of the main design philosophies of \CFA is to ``\Index{describe not prescribe}'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''. +Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming. +A programmer is always free to reach back to C from \CFA, for any reason, and in many cases, new \CFA features can be locally switched back to there C counterpart. +There is no notion or requirement for \emph{rewriting} a legacy C program in \CFA; +instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features. +As well, new programs can be written in \CFA using a combination of C and \CFA features. + +\Index*[C++]{\CC{}} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C. +However, \CC currently has the disadvantages of a strong object-oriented bias, multiple legacy design-choices that cannot be updated, and active divergence of the language model from C, all of which requires significant effort and training to incrementally add \CC to a C-based project. In contrast, \CFA has 30 years of hindsight and a clean starting point. @@ -156,15 +162,6 @@ \begin{quote2} \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}} -\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CC}} \\ -\begin{cfa} -#include §\indexc{fstream}§ - -int main( void ) { - int x = 0, y = 1, z = 2; - ®sout | x | y | z | endl;® -} -\end{cfa} -& -\begin{lstlisting} +\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{\CC}} \\ +\begin{cfa} #include §\indexc{stdio.h}§ @@ -173,7 +170,16 @@ ®printf( "%d %d %d\n", x, y, z );® } -\end{lstlisting} +\end{cfa} & -\begin{lstlisting} +\begin{cfa} +#include §\indexc{fstream}§ + +int main( void ) { + int x = 0, y = 1, z = 2; + ®sout | x | y | z | endl;®§\indexc{sout}§ +} +\end{cfa} +& +\begin{cfa} #include §\indexc{iostream}§ using namespace std; @@ -182,14 +188,16 @@ ®cout<i +® j = 3; ®// this->j +® } +} +\end{C++} +Since CFA is non-object-oriented, the equivalent object-oriented program looks like: +\begin{cfa} +struct C { + int i, j; +}; +int mem( C &this ) { + ®this.®i = 1; // "this" is not elided + ®this.®j = 2; +} +\end{cfa} +but it is cumbersome having to write "©this.©" many times in a member. +\CFA provides a ©with© clause/statement to elided the "©this.©". +\begin{cfa} +int mem( C &this ) ®with this® { + i = 1; ®// this.i +® j = 2; ®// this.j +®} +\end{cfa} +which extends to multiple routine parameters: +\begin{cfa} +struct D { + double m, n; +}; +int mem2( C &this1, D &this2 ) ®with this1, this2® { + i = 1; j = 2; + m = 1.0; n = 2.0; +} +\end{cfa} +The ©with© clause/statement comes from Pascal~\cite[\S~4.F]{Pascal}. + +The statement form is used within a block: +\begin{cfa} +int foo() { + struct S1 { ... } s1; + struct S2 { ... } s2; + ®with s1® { + // access fields of s1 without qualification + ®with s2® { // nesting + // access fields of s2 without qualification + } + } + ®with s1, s2® { + // access unambiguous fields of s1 and s2 without qualification + } +} +\end{cfa} + +Names clashes when opening multiple structures are ambiguous. +\begin{cfa} +struct A { int i; int j; } a, c; +struct B { int i; int k; } b, c; +®with a, b® { + j + k; §\C{// unambiguous}§ + i; §\C{// ambiguous}§ + a.i + b.i; §\C{// unambiguous}§ +} +®with c® { §\C{// ambiguous}§ + // ... +} +\end{cfa} \section{Exception Handling} @@ -5261,40 +5346,46 @@ \label{s:CFAKeywords} +\CFA introduces the following new keywords. + \begin{quote2} -\begin{tabular}{llll} +\begin{tabular}{lllll} \begin{tabular}{@{}l@{}} -©_AT© \\ +©_At© \\ ©catch© \\ ©catchResume© \\ ©choose© \\ ©coroutine© \\ -©disable© \\ \end{tabular} & \begin{tabular}{@{}l@{}} +©disable© \\ ©dtype© \\ ©enable© \\ ©fallthrough© \\ ©fallthru© \\ -©finally© \\ -©forall© \\ \end{tabular} & \begin{tabular}{@{}l@{}} +©finally© \\ +©forall© \\ ©ftype© \\ ©lvalue© \\ ©monitor© \\ +\end{tabular} +& +\begin{tabular}{@{}l@{}} ©mutex© \\ ©one_t© \\ ©otype© \\ +©throw© \\ +©throwResume© \\ \end{tabular} & \begin{tabular}{@{}l@{}} -©throw© \\ -©throwResume© \\ ©trait© \\ ©try© \\ ©ttype© \\ ©zero_t© \\ + \\ \end{tabular} \end{tabular}