Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/user/user.tex

    r86f384b re9a3c69d  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Sun Jul  2 09:49:56 2017
    14 %% Update Count     : 2503
     13%% Last Modified On : Thu Jul 13 11:44:57 2017
     14%% Update Count     : 2690
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    5757\CFAStyle                                                                                               % use default CFA format-style
    5858
     59\lstnewenvironment{C++}[1][]
     60{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
     61{}
     62
    5963% inline code ©...© (copyright symbol) emacs: C-q M-)
    6064% red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
    … …  
    137141
    138142\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.
    139 The syntax of the \CFA language builds from C, and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
     143The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
    140144% Any language feature that is not described here can be assumed to be using the standard \Celeven syntax.
    141 \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.
    142 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.
     145\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.
     146Like 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.
    143147The primary new features include parametric-polymorphic routines and types, exceptions, concurrency, and modules.
    144148
    145 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''.
    146 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.
    147 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.
    148 There is no notion or requirement for rewriting a legacy C program in \CFA;
    149 instead, a programmer evolves an existing C program into \CFA by incrementally incorporating \CFA features.
    150 New programs can be written in \CFA using a combination of C and \CFA features.
    151 \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.
     149One 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''.
     150Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming.
     151A 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.
     152There is no notion or requirement for \emph{rewriting} a legacy C program in \CFA;
     153instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features.
     154As well, new programs can be written in \CFA using a combination of C and \CFA features.
     155
     156\Index*[C++]{\CC{}} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
     157However, \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.
    152158In contrast, \CFA has 30 years of hindsight and a clean starting point.
    153159
    … …  
    156162\begin{quote2}
    157163\begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
    158 \multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{\CFA}}      & \multicolumn{1}{c}{\textbf{C}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
    159 \begin{cfa}
    160 #include <fstream>§\indexc{fstream}§
    161 
    162 int main( void ) {
    163         int x = 0, y = 1, z = 2;
    164         ®sout | x | y | z | endl;®
    165 }
    166 \end{cfa}
    167 &
    168 \begin{lstlisting}
     164\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
     165\begin{cfa}
    169166#include <stdio.h>§\indexc{stdio.h}§
    170167
    … …  
    173170        ®printf( "%d %d %d\n", x, y, z );®
    174171}
    175 \end{lstlisting}
     172\end{cfa}
    176173&
    177 \begin{lstlisting}
     174\begin{cfa}
     175#include <fstream>§\indexc{fstream}§
     176
     177int main( void ) {
     178        int x = 0, y = 1, z = 2;
     179        ®sout | x | y | z | endl;®§\indexc{sout}§
     180}
     181\end{cfa}
     182&
     183\begin{cfa}
    178184#include <iostream>§\indexc{iostream}§
    179185using namespace std;
    … …  
    182188        ®cout<<x<<" "<<y<<" "<<z<<endl;®
    183189}
    184 \end{lstlisting}
     190\end{cfa}
    185191\end{tabular}
    186192\end{quote2}
    187193While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
    188194
     195\subsection{Background}
     196
    189197This document is a programmer reference-manual for the \CFA programming language.
    190198The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
    191199The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
    192 A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented as well as some experience programming in C/\CC.
    193 Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
     200A reader should already have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
     201Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
    194202Changes to the syntax and additional features are expected to be included in later revisions.
    195203
    … …  
    200208This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
    201209Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
    202 For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
     210For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
    203211The TIOBE index~\cite{TIOBE} for March 2016 showed the following programming-language popularity: \Index*{Java} 20.5\%, C 14.5\%, \Index*[C++]{\CC{}} 6.7\%, \Csharp 4.3\%, \Index*{Python} 4.3\%, where the next 50 languages are less than 3\% each with a long tail.
    204212As well, for 30 years, C has been the number 1 and 2 most popular programming language:
    … …  
    216224\end{center}
    217225Hence, C is still an extremely important programming language, with double the usage of \Index*[C++]{\CC{}}; in many cases, \CC is often used solely as a better C.
    218 Love it or hate it, C has been an important and influential part of computer science for 40 years and sit appeal is not diminishing.
    219 Unfortunately, C has too many problems and omissions to make it an acceptable programming language for modern needs.
    220 
    221 As stated, the goal of the \CFA project is to engineer modern language features into C in an evolutionary rather than revolutionary way.
     226Love it or hate it, C has been an important and influential part of computer science for 40 years and its appeal is not diminishing.
     227Unfortunately, C has many problems and omissions that make it an unacceptable programming language for modern needs.
     228
     229As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
    222230\CC~\cite{C++14,C++} is an example of a similar project;
    223 however, it largely extended the language, and did not address many existing problems.\footnote{%
     231however, it largely extended the C language, and did not address most of C's existing problems.\footnote{%
    224232Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
    225 \Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
     233\Index*{Fortran}~\cite{Fortran08}, \Index*{Ada}~\cite{Ada12}, and \Index*{Cobol}~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language-features (\eg objects, concurrency) are added and problems fixed within the framework of the existing language.
    226234\Index*{Java}~\cite{Java8}, \Index*{Go}~\cite{Go}, \Index*{Rust}~\cite{Rust} and \Index*{D}~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
    227 These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
     235These languages have different syntax and semantics from C, do not interoperate directly with C, and are not systems languages because of restrictive memory-management or garbage collection.
    228236As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
    229 These costs can be prohibitive for many companies with a large software base in C/\CC, and a significant number of programmers requiring retraining to a new programming language.
    230 
    231 The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixing some of the well known C problems and containing many modern language features.
     237These costs can be prohibitive for many companies with a large software-base in C/\CC, and a significant number of programmers require retraining to the new programming language.
     238
     239The result of this project is a language that is largely backwards compatible with \Index*[C11]{\Celeven{}}~\cite{C11}, but fixes many of the well known C problems while containing modern language-features.
    232240Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
    233241as a result, it will fade into disuse.
    234242Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
    235 While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language features.
    236 While some may argue that modern language features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
     243While \Index*[C11]{\Celeven{}} made a few simple extensions to the language, nothing was added to address existing problems in the language or to augment the language with modern language-features.
     244While some may argue that modern language-features may make C complex and inefficient, it is clear a language without modern capabilities is insufficient for the advanced programming problems existing today.
    237245
    238246
    239247\section{History}
    240248
    241 The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.
     249The \CFA project started with \Index*{K-W C}~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and advanced assignment capabilities using the notion of tuples.
    242250(See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
    243 A first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
    244 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
     251The first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
     252
     253The signature feature of \CFA is \Index{overload}able \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
    245254\begin{lstlisting}
    246255®forall( otype T )® T identity( T val ) { return val; }
    … …  
    250259\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfiled~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
    251260However, at that time, there was little interesting in extending C, so work did not continue.
    252 As the saying goes, ``What goes around, comes around.'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
     261As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
    253262
    254263
    … …  
    257266
    258267\CFA is designed to integrate directly with existing C programs and libraries.
    259 The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no overhead to call existing C routines.
     268The most important feature of \Index{interoperability} is using the same \Index{calling convention}s, so there is no complex interface or overhead to call existing C routines.
    260269This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
    261270Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
    262271Fortunately, \CFA, like \Index*[C++]{\CC{}}, starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.
    263 Hence, \CFA begins by leveraging the large repository of C libraries with little cost.
     272Hence, \CFA begins by leveraging the large repository of C libraries at little cost.
    264273
    265274\begin{comment}
    … …  
    304313\end{comment}
    305314
    306 However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC.
     315However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
    307316For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
    308 Whereas, \CFA wraps each of these routines into ones with the common name ©abs©:
     317Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
    309318\begin{cfa}
    310319char abs( char );
    … …  
    326335Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
    327336There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
    328 This example strongly illustrates a core idea in \CFA: \emph{the power of a name}.
     337This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
    329338The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
    330 Hence, knowing the name ©abs© should be sufficient to apply it to any type where it is applicable.
    331 The time savings and safety of using one name uniformly versus $N$ unique names should not be underestimated.
    332 
    333 
    334 \section[Compiling CFA Program]{Compiling \CFA Program}
     339Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
     340The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
     341
     342
     343\section[Compiling a CFA Program]{Compiling a \CFA Program}
    335344
    336345The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
    337346\begin{cfa}
    338 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
     347cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA{}§-files [ assembler/loader-files ]
    339348\end{cfa}
    340349\CFA programs having the following ©gcc© flags turned on:
    … …  
    359368\Indexc{-debug}\index{compilation option!-debug@©-debug©}
    360369The program is linked with the debugging version of the runtime system.
    361 The debug version performs runtime checks to help during the debugging phase of a \CFA program, but substantially slows the execution of the program.
     370The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution.
    362371The runtime checks should only be removed after the program is completely debugged.
    363372\textbf{This option is the default.}
    … …  
    415424\end{description}
    416425These preprocessor variables allow conditional compilation of programs that must work differently in these situations.
    417 For example, to toggle between C and \CFA extensions, using the following:
     426For example, to toggle between C and \CFA extensions, use the following:
    418427\begin{cfa}
    419428#ifndef __CFORALL__
    … …  
    426435
    427436
    428 \section{Constants Underscores}
    429 
    430 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, \eg:
     437\section{Constant Underscores}
     438
     439Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
    431440\begin{cfa}
    4324412®_®147®_®483®_®648;                                    §\C{// decimal constant}§
    … …  
    441450L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
    442451\end{cfa}
    443 The rules for placement of underscores is as follows:
    444 \begin{enumerate}
     452The rules for placement of underscores are:
     453\begin{enumerate}[topsep=5pt,itemsep=5pt,parsep=0pt]
    445454\item
    446455A sequence of underscores is disallowed, \eg ©12__34© is invalid.
    … …  
    463472\label{s:BackquoteIdentifiers}
    464473
    465 \CFA accommodates keyword clashes with existing C variable-names by syntactic transformations using the \CFA backquote escape-mechanism:
     474\CFA introduces in new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
     475Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
    466476\begin{cfa}
    467477int ®`®otype®`® = 3;                    §\C{// make keyword an identifier}§
    … …  
    491501
    492502
    493 \section{Labelled Continue/Break}
     503\section{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break}}{Labelled continue / break}}
    494504
    495505While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
    496506Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
    497 To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85,Java}.
     507To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@\lstinline $continue$!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@\lstinline $break$!labelled}\index{labelled!break@©break©} with a target label to support static multi-level exit\index{multi-level exit}\index{static multi-level exit}~\cite{Buhr85}.
    498508For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
    499509for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
    500510\VRef[Figure]{f:MultiLevelResumeTermination} shows the labelled ©continue© and ©break©, specifying which control structure is the target for exit, and the corresponding C program using only ©goto©.
    501511The innermost loop has 7 exit points, which cause resumption or termination of one or more of the 7 \Index{nested control-structure}s.
     512Java supports both labelled ©continue© and ©break© statements.
    502513
    503514\begin{figure}
    … …  
    622633
    623634
    624 \section{Switch Statement}
     635\section{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
    625636
    626637C allows a number of questionable forms for the ©switch© statement:
    … …  
    663674        ®// open input file
    664675®} else if ( argc == 2 ) {
    665         ®// open input file
     676        ®// open input file (duplicate)
    666677
    667678®} else {
    … …  
    676687\begin{cfa}
    677688switch ( i ) {
    678   case 1: case 3: case 5:       // odd values
    679         // same action
     689  ®case 1: case 3: case 5:®     // odd values
     690        // odd action
    680691        break;
    681   case 2: case 4: case 6:       // even values
    682         // same action
     692  ®case 2: case 4: case 6:®     // even values
     693        // even action
    683694        break;
    684695}
    … …  
    686697However, this situation is handled in other languages without fall-through by allowing a list of case values.
    687698While 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 virtually all other programming languages with a ©switch© statement.
    688 Hence, default fall-through semantics results in a large number of programming errors as programmers often forget the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
     699Hence, 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.
    689700
    690701\item
    … …  
    770781and 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.
    771782\end{itemize}
    772 These observations help to put the \CFA changes to the ©switch© into perspective.
     783These observations put into perspective the \CFA changes to the ©switch©.
    773784\begin{enumerate}
    774785\item
    … …  
    791802  case 7:
    792803        ...
    793         ®break®                                         §\C{// explicit end of switch}§
     804        ®break®                                         §\C{// redundant explicit end of switch}§
    794805  default:
    795806        j = 3;
    … …  
    797808\end{cfa}
    798809Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
    799 the implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
    800 The explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
     810An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
     811An explicit ©fallthru© is retained because it is a C-idiom most C programmers expect, and its absence might discourage programmers from using the ©choose© statement.
    801812As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
    802813\item
    … …  
    827838
    828839
    829 \section{Case Clause}
     840\section{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
    830841
    831842C restricts the ©case© clause of a ©switch© statement to a single value.
    … …  
    900911\begin{cfa}
    901912case ®1~5, 12~21, 35~42®:
     913\end{cfa}
     914
     915
     916\section{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
     917\label{s:WithClauseStatement}
     918
     919In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
     920\begin{C++}
     921class C {
     922        int i, j;
     923        int mem() {              ®// implicit "this" parameter
     924                i = 1;          ®// this->i
     925®               j = 3;          ®// this->j
     926®       }
     927}
     928\end{C++}
     929Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
     930\begin{cfa}
     931struct C {
     932        int i, j;
     933};
     934int mem( C &this ) {    // explicit "this" parameter
     935        ®this.®i = 1;                     // "this" is not elided
     936        ®this.®j = 2;
     937}
     938\end{cfa}
     939but it is cumbersome having to write "©this.©" many times in a member.
     940\CFA provides a ©with© clause/statement to elided the "©this.©".
     941\begin{cfa}
     942int mem( C &this ) ®with this® {
     943        i = 1;                  ®// this.i
     944®       j = 2;                  ®// this.j
     945®}
     946\end{cfa}
     947which extends to multiple routine parameters:
     948\begin{cfa}
     949struct D {
     950        double m, n;
     951};
     952int mem2( C &this1, D &this2 ) ®with this1, this2® {
     953        i = 1; j = 2;
     954        m = 1.0; n = 2.0;
     955}
     956\end{cfa}
     957The ©with© clause/statement comes from Pascal~\cite[\S~4.F]{Pascal}.
     958
     959The statement form is used within a block:
     960\begin{cfa}
     961int foo() {
     962        struct S1 { ... } s1;
     963        struct S2 { ... } s2;
     964        ®with s1® {
     965                // access fields of s1 without qualification
     966                ®with s2® {  // nesting
     967                        // access fields of s2 without qualification
     968                }
     969        }
     970        ®with s1, s2® {
     971                // access unambiguous fields of s1 and s2 without qualification
     972        }
     973}
     974\end{cfa}
     975
     976Names clashes when opening multiple structures are ambiguous.
     977\begin{cfa}
     978struct A { int i; int j; } a, c;
     979struct B { int i; int k; } b, c;
     980®with a, b® {
     981        j + k;                                          §\C{// unambiguous}§
     982        i;                                                      §\C{// ambiguous}§
     983        a.i + b.i;                                      §\C{// unambiguous}§
     984}
     985®with c® {                                              §\C{// ambiguous}§
     986        // ...
     987}
    902988\end{cfa}
    903989
    … …  
    11361222
    11371223
    1138 \section{Pointer/Reference}
     1224\section{Pointer / Reference}
    11391225
    11401226C provides a \newterm{pointer type};
    … …  
    24502536\end{cfa}
    24512537\\
    2452 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     2538\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    245325391® ®2® ®3
    24542540\end{cfa}
    24552541&
    2456 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     2542\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    245725431 2 3
    24582544\end{cfa}
    … …  
    24612547The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators.
    24622548Similar simplification occurs for \Index{tuple} I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
    2463 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2464 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 3, [ 4, 5 ] ];
     2549\begin{cfa}
     2550[int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
    24652551sout | t1 | t2 | endl;                                  §\C{// print tuples}§
    24662552\end{cfa}
    2467 \begin{cfa}[mathescape=off,showspaces=true,belowskip=0pt]
    2468 1®, ®2®, ®3 3®, ®4®, ®5
     2553\begin{cfa}[showspaces=true,aboveskip=0pt]
     25541®, ®2®, ®3 4®, ®5®, ®6
    24692555\end{cfa}
    24702556Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
    … …  
    24852571\\
    24862572&
    2487 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     2573\begin{cfa}[showspaces=true,aboveskip=0pt]
    248825743 3 12 0 3 1 2
    24892575\end{cfa}
    … …  
    25032589sout | 1 | 2 | 3 | endl;
    25042590\end{cfa}
    2505 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     2591\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    250625921 2 3
    25072593\end{cfa}
    … …  
    25702656\subsection{Manipulator}
    25712657
    2572 The following routines and \CC-style \Index{manipulator}s control implicit seperation.
     2658The following \CC-style \Index{manipulator}s and routines control implicit seperation.
    25732659\begin{enumerate}
    25742660\item
    2575 Routines \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
     2661Routines \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.
    25762662The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    2577 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
     2663\begin{cfa}[mathescape=off,belowskip=0pt]
    25782664sepSet( sout, ", $" );                                          §\C{// set separator from " " to ", \$"}§
    2579 sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl;
     2665sout | 1 | 2 | 3 | " \"" | ®sep® | "\"" | endl;
    25802666\end{cfa}
    25812667%$
    … …  
    25842670\end{cfa}
    25852671%$
    2586 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
     2672\begin{cfa}[belowskip=0pt]
    25872673sepSet( sout, " " );                                            §\C{// reset separator to " "}§
    25882674sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"" | endl;
    25892675\end{cfa}
    2590 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
     2676\begin{cfa}[showspaces=true,aboveskip=0pt]
    259126771® ®2® ®3 ®" "®
    25922678\end{cfa}
    2593 
    2594 \item
    2595 Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
     2679©sepGet© can be used to store a separator and then restore it:
     2680\begin{cfa}[belowskip=0pt]
     2681char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
     2682strcpy( store, sepGet( sout ) );
     2683sepSet( sout, "_" );
     2684sout | 1 | 2 | 3 | endl;
     2685\end{cfa}
     2686\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     26871®_®2®_®3
     2688\end{cfa}
     2689\begin{cfa}[belowskip=0pt]
     2690sepSet( sout, store );
     2691sout | 1 | 2 | 3 | endl;
     2692\end{cfa}
     2693\begin{cfa}[showspaces=true,aboveskip=0pt]
     26941® ®2® ®3
     2695\end{cfa}
     2696
     2697\item
     2698Routine \Indexc{sepSetTuple}\index{manipulator!sepSetTuple@©sepSetTuple©} and \Indexc{sepTuple}\index{manipulator!sepTuple@©sepTuple©}/\Indexc{sepGetTuple}\index{manipulator!sepGetTuple@©sepGetTuple©} get and set the tuple separator-string.
    25962699The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    2597 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
     2700\begin{cfa}[belowskip=0pt]
    25982701sepSetTuple( sout, " " );                                       §\C{// set tuple separator from ", " to " "}§
    2599 sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl;
    2600 \end{cfa}
    2601 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
    2602 1 2 3 4 ®" "®
    2603 \end{cfa}
    2604 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
     2702sout | t1 | t2 | " \"" | ®sepTuple® | "\"" | endl;
     2703\end{cfa}
     2704\begin{cfa}[showspaces=true,aboveskip=0pt]
     27051 2 3 4 5 6 ®" "®
     2706\end{cfa}
     2707\begin{cfa}[belowskip=0pt]
    26052708sepSetTuple( sout, ", " );                                      §\C{// reset tuple separator to ", "}§
    26062709sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"" | endl;
    26072710\end{cfa}
    2608 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
    2609 1, 2, 3, 4 ®", "®
    2610 \end{cfa}
    2611 
    2612 \item
    2613 Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item.
    2614 \begin{cfa}[mathescape=off,belowskip=0pt]
    2615 sout | sepOn | 1 | 2 | 3 | sepOn | endl;        §\C{// separator at start/end of line}§
    2616 \end{cfa}
    2617 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    2618 ® ®1 2 3® ®
    2619 \end{cfa}
    2620 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2621 sout | 1 | sepOff | 2 | 3 | endl;                       §\C{// locally turn off implicit separator}§
    2622 \end{cfa}
    2623 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    2624 12 3
    2625 \end{cfa}
    2626 The tuple separator also responses to being turned on and off.
    2627 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2628 sout | sepOn | t1 | sepOff | t2 | endl;         §\C{// locally turn on/off implicit separation}§
    2629 \end{cfa}
    2630 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    2631 , 1, 23, 4
    2632 \end{cfa}
    2633 Notice a tuple seperator starts the line because the next item is a tuple.
    2634 
    2635 \item
    2636 Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items, unless locally adjusted.
    2637 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2638 sout | sepDisable | 1 | 2 | 3 | endl;           §\C{// globally turn off implicit separation}§
    2639 \end{cfa}
    2640 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
     2711\begin{cfa}[showspaces=true,aboveskip=0pt]
     27121, 2, 3 4, 5, 6 ®", "®
     2713\end{cfa}
     2714As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
     2715
     2716\item
     2717Manipulators \Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} \emph{globally} toggle printing the separator, \ie the seperator is adjusted with respect to all subsequent printed items.
     2718\begin{cfa}[belowskip=0pt]
     2719sout | sepDisable | 1 | 2 | 3 | endl;           §\C{// globally turn off implicit separator}§
     2720\end{cfa}
     2721\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    26412722123
    26422723\end{cfa}
    2643 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2644 sout | 1 | ®sepOn® | 2 | 3 | endl;                      §\C{// locally turn on implicit separator}§
    2645 \end{cfa}
    2646 \begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    2647 1® ®23
    2648 \end{cfa}
    2649 \begin{cfa}[mathescape=off,aboveskip=0pt,belowskip=0pt]
    2650 sout | sepEnable | 1 | 2 | 3 | endl;            §\C{// globally turn on implicit separation}§
     2724\begin{cfa}[belowskip=0pt]
     2725sout | sepEnable | 1 | 2 | 3 | endl;            §\C{// globally turn on implicit separator}§
    26512726\end{cfa}
    26522727\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    265327281 2 3
    26542729\end{cfa}
     2730
     2731\item
     2732Manipulators \Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} \emph{locally} toggle printing the separator, \ie the seperator is adjusted only with respect to the next printed item.
     2733\begin{cfa}[belowskip=0pt]
     2734sout | 1 | sepOff | 2 | 3 | endl;                       §\C{// locally turn off implicit separator}§
     2735\end{cfa}
     2736\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     273712 3
     2738\end{cfa}
     2739\begin{cfa}[belowskip=0pt]
     2740sout | sepDisable | 1 | sepOn | 2 | 3 | endl; §\C{// locally turn on implicit separator}§
     2741\end{cfa}
     2742\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     27431 23
     2744\end{cfa}
     2745The tuple separator also responses to being turned on and off.
     2746\begin{cfa}[belowskip=0pt]
     2747sout | t1 | sepOff | t2 | endl;                         §\C{// locally turn on/off implicit separator}§
     2748\end{cfa}
     2749\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     27501, 2, 34, 5, 6
     2751\end{cfa}
     2752©sepOn© \emph{cannot} be used to start/end a line with a separator because separators do not appear at the start/end of a line;
     2753use ©sep© to accomplish this functionality.
     2754\begin{cfa}[belowskip=0pt]
     2755sout | sepOn | 1 | 2 | 3 | sepOn | endl ;       §\C{// sepOn does nothing at start/end of line}§
     2756\end{cfa}
     2757\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     27581 2 3
     2759\end{cfa}
     2760\begin{cfa}[belowskip=0pt]
     2761sout | sep | 1 | 2 | 3 | sep | endl ;           §\C{// use sep to print separator at start/end of line}§
     2762\end{cfa}
     2763\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
     2764® ®1 2 3® ®
     2765\end{cfa}
    26552766\end{enumerate}
    26562767
    26572768\begin{comment}
    26582769#include <fstream>
     2770#include <string.h>                                                                             // strcpy
    26592771
    26602772int main( void ) {
    26612773        int x = 1, y = 2, z = 3;
    26622774        sout | x | y | z | endl;
    2663         [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 3, [ 4, 5 ] ];
     2775        [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
    26642776        sout | t1 | t2 | endl;                                          // print tuples
    26652777        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
    … …  
    26752787
    26762788        sepSet( sout, ", $" );                                          // set separator from " " to ", $"
    2677         sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
     2789        sout | 1 | 2 | 3 | " \"" | sep | "\"" | endl;
    26782790        sepSet( sout, " " );                                            // reset separator to " "
    26792791        sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl;
    26802792
    2681         sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
    2682         sout | 1 | sepOff | 2 | 3 | endl;                       // locally turn off implicit separator
    2683 
    2684         sout | sepDisable | 1 | 2 | 3 | endl;           // globally turn off implicit separation
    2685         sout | 1 | sepOn | 2 | 3 | endl;                        // locally turn on implicit separator
    2686         sout | sepEnable | 1 | 2 | 3 | endl;            // globally turn on implicit separation
     2793        char store[sepSize];
     2794        strcpy( store, sepGet( sout ) );
     2795        sepSet( sout, "_" );
     2796        sout | 1 | 2 | 3 | endl;
     2797        sepSet( sout, store );
     2798        sout | 1 | 2 | 3 | endl;
    26872799
    26882800        sepSetTuple( sout, " " );                                       // set tuple separator from ", " to " "
    2689         sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
     2801        sout | t1 | t2 | " \"" | sepTuple | "\"" | endl;
    26902802        sepSetTuple( sout, ", " );                                      // reset tuple separator to ", "
    26912803        sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl;
    26922804
    2693         sout | t1 | t2 | endl;                                          // print tuple
    2694         sout | sepOn | t1 | sepOff | t2 | endl;         // locally turn on/off implicit separation
     2805        sout | sepDisable | 1 | 2 | 3 | endl;           // globally turn off implicit separator
     2806        sout | sepEnable | 1 | 2 | 3 | endl;            // globally turn on implicit separator
     2807       
     2808        sout | 1 | sepOff | 2 | 3 | endl;                       // locally turn on implicit separator
     2809        sout | sepDisable | 1 | sepOn | 2 | 3 | endl; // globally turn off implicit separator
     2810        sout | sepEnable;
     2811        sout | t1 | sepOff | t2 | endl;                         // locally turn on/off implicit separator
     2812
     2813        sout | sepOn | 1 | 2 | 3 | sepOn | endl ;       // sepOn does nothing at start/end of line
     2814        sout | sep | 1 | 2 | 3 | sep | endl ;           // use sep to print separator at start/end of line
    26952815}
    26962816
    … …  
    52245344
    52255345
    5226 \section{\CFA Keywords}
     5346\section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
    52275347\label{s:CFAKeywords}
    52285348
     5349\CFA introduces the following new keywords.
     5350
    52295351\begin{quote2}
    5230 \begin{tabular}{llll}
     5352\begin{tabular}{lllll}
    52315353\begin{tabular}{@{}l@{}}
    5232 ©_AT©                   \\
     5354©_At©                   \\
    52335355©catch©                 \\
    52345356©catchResume©   \\
    52355357©choose©                \\
    52365358©coroutine©             \\
    5237 ©disable©               \\
    52385359\end{tabular}
    52395360&
    52405361\begin{tabular}{@{}l@{}}
     5362©disable©               \\
    52415363©dtype©                 \\
    52425364©enable©                \\
    52435365©fallthrough©   \\
    52445366©fallthru©              \\
    5245 ©finally©               \\
    5246 ©forall©                \\
    52475367\end{tabular}
    52485368&
    52495369\begin{tabular}{@{}l@{}}
     5370©finally©               \\
     5371©forall©                \\
    52505372©ftype©                 \\
    52515373©lvalue©                \\
    52525374©monitor©               \\
     5375\end{tabular}
     5376&
     5377\begin{tabular}{@{}l@{}}
    52535378©mutex©                 \\
    52545379©one_t©                 \\
    52555380©otype©                 \\
     5381©throw©                 \\
     5382©throwResume©   \\
    52565383\end{tabular}
    52575384&
    52585385\begin{tabular}{@{}l@{}}
    5259 ©throw©                 \\
    5260 ©throwResume©   \\
    52615386©trait©                 \\
    52625387©try©                   \\
    52635388©ttype©                 \\
    52645389©zero_t©                \\
     5390                                \\
    52655391\end{tabular}
    52665392\end{tabular}
    … …  
    55485674// C unsafe allocation
    55495675extern "C" {
    5550 void * mallac( size_t size );§\indexc{memset}§
     5676void * malloc( size_t size );§\indexc{memset}§
    55515677void * calloc( size_t dim, size_t size );§\indexc{calloc}§
    55525678void * realloc( void * ptr, size_t size );§\indexc{realloc}§
Note: See TracChangeset for help on using the changeset viewer.