Changeset 33218c6 for doc/user/user.tex

Timestamp:

Jul 26, 2017, 12:19:41 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b947fb2

Parents:

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

Message:

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

File:

• doc/user/user.tex (modified) (48 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% 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 : Sat Jul 22 11:01:19 2017
+%% Update Count     : 2878
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -57 +57 @@
 \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 +141 @@
 
 \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 +162 @@
 \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 <fstream>§\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 <stdio.h>§\indexc{stdio.h}§
 
@@ -173 +170 @@
         ®printf( "%d %d %d\n", x, y, z );®
 }
-\end{lstlisting}
+\end{cfa}
 &
-\begin{lstlisting}
+\begin{cfa}
+#include <fstream>§\indexc{fstream}§
+
+int main( void ) {
+        int x = 0, y = 1, z = 2;
+        ®sout | x | y | z | endl;®§\indexc{sout}§
+}
+\end{cfa}
+&
+\begin{cfa}
 #include <iostream>§\indexc{iostream}§
 using namespace std;
@@ -182 +188 @@
         ®cout<<x<<" "<<y<<" "<<z<<endl;®
 }
-\end{lstlisting}
+\end{cfa}
 \end{tabular}
 \end{quote2}
 While 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}).
 
+\subsection{Background}
+
 This document is a programmer reference-manual for the \CFA programming language.
 The manual covers the core features of the language and runtime-system, with simple examples illustrating syntax and semantics of each feature.
 The manual does not teach programming, i.e., how to combine the new constructs to build complex programs.
-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.
-Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
+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.
+Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 Changes to the syntax and additional features are expected to be included in later revisions.
 
@@ -200 +208 @@
 This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
-For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
+For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
 The 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.
 As well, for 30 years, C has been the number 1 and 2 most popular programming language:
@@ -216 +224 @@
 \end{center}
 Hence, 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.
-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.
-Unfortunately, C has too many problems and omissions to make it an acceptable programming language for modern needs.
-
-As stated, the goal of the \CFA project is to engineer modern language features into C in an evolutionary rather than revolutionary way.
+Love it or hate it, C has been an important and influential part of computer science for 40 years and its appeal is not diminishing.
+Unfortunately, C has many problems and omissions that make it an unacceptable programming language for modern needs.
+
+As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
 \CC~\cite{C++14,C++} is an example of a similar project;
-however, it largely extended the language, and did not address many existing problems.\footnote{%
+however, it largely extended the C language, and did not address most of C's existing problems.\footnote{%
 Two 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.}
-\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.
+\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.
 \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.
-These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
+These 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.
 As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
-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.
-
-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.
+These 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.
+
+The 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.
 Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
 as a result, it will fade into disuse.
 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
-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.
-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.
+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.
+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.
 
 
 \section{History}
 
-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.
+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 advanced assignment capabilities using the notion of tuples.
 (See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
-A first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
-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):
+The first \CFA implementation of these extensions was by Esteves~\cite{Esteves04}.
+
+The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
@@ -248 +257 @@
 \end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
-\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfiled~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
+\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
 However, at that time, there was little interesting in extending C, so work did not continue.
-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.
+As 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.
 
 
@@ -257 +266 @@
 
 \CFA is designed to integrate directly with existing C programs and libraries.
-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.
+The 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.
 This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
 Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
 Fortunately, \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.
-Hence, \CFA begins by leveraging the large repository of C libraries with little cost.
+Hence, \CFA begins by leveraging the large repository of C libraries, and than allows programmers to incrementally augment their C programs with modern \Index{backward-compatible} features.
 
 \begin{comment}
@@ -304 +313 @@
 \end{comment}
 
-However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC.
+However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
 For 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©.
-Whereas, \CFA wraps each of these routines into ones with the common name ©abs©:
+Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
 \begin{cfa}
 char abs( char );
-®extern "C" {®
-int abs( int );                                                 §\C{// use default C routine for int}§
-®}® // extern "C"
+®extern "C" {® int abs( int ); ®}®              §\C{// use default C routine for int}§
 long int abs( long int );
 long long int abs( long long int );
@@ -326 +333 @@
 Hence, 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.
 There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
-This example strongly illustrates a core idea in \CFA: \emph{the power of a name}.
+
+This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
 The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
-Hence, knowing the name ©abs© should be sufficient to apply it to any type where it is applicable.
-The time savings and safety of using one name uniformly versus $N$ unique names should not be underestimated.
-
-
-\section[Compiling CFA Program]{Compiling \CFA Program}
-
-The command ©cfa© is used to compile \CFA program(s), and is based on the GNU \Indexc{gcc} command, \eg:
-\begin{cfa}
-cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
+Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
+The time savings and safety of using one name uniformly versus $N$ unique names cannot be underestimated.
+
+
+\section[Compiling a CFA Program]{Compiling a \CFA Program}
+
+The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
+\begin{cfa}
+cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA{}§-files [ assembler/loader-files ]
 \end{cfa}
 \CFA programs having the following ©gcc© flags turned on:
@@ -344 +352 @@
 The 1999 C standard plus GNU extensions.
 \item
-{\lstset{deletekeywords={inline}}
-\Indexc{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{©-fgnu89-inline©}}
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
-}%
 \end{description}
 The following new \CFA options are available:
@@ -354 +360 @@
 \Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
-The generated code started with the standard \CFA prelude.
+The generated code starts with the standard \CFA \Index{prelude}.
 
 \item
 \Indexc{-debug}\index{compilation option!-debug@©-debug©}
 The program is linked with the debugging version of the runtime system.
-The debug version performs runtime checks to help during the debugging phase of a \CFA program, but substantially slows the execution of the program.
+The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution.
 The runtime checks should only be removed after the program is completely debugged.
 \textbf{This option is the default.}
@@ -366 +372 @@
 \Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
 The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
-\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program termination.}
+\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program behaviour or termination.}
 
 \item
@@ -386 +392 @@
 \textbf{This option is the default.}
 
+\begin{comment}
 \item
 \Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
 Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
 \textbf{This option is \emph{not} the default.}
+\end{comment}
 \end{description}
 
@@ -410 +418 @@
 \item
 \Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©},
-\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©} and
+\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}, and
 \Indexc{__cforall}\index{preprocessor variables!__cforall@©__cforall©}
 are always available during preprocessing and have no value.
 \end{description}
 These preprocessor variables allow conditional compilation of programs that must work differently in these situations.
-For example, to toggle between C and \CFA extensions, using the following:
+For example, to toggle between C and \CFA extensions, use the following:
 \begin{cfa}
 #ifndef __CFORALL__
@@ -426 +434 @@
 
 
-\section{Constants Underscores}
-
-Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, \eg:
+\section{Constant Underscores}
+
+Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
 \begin{cfa}
 2®_®147®_®483®_®648;                                    §\C{// decimal constant}§
@@ -441 +449 @@
 L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
 \end{cfa}
-The rules for placement of underscores is as follows:
-\begin{enumerate}
+The rules for placement of underscores are:
+\begin{enumerate}[topsep=5pt,itemsep=5pt,parsep=0pt]
 \item
 A sequence of underscores is disallowed, \eg ©12__34© is invalid.
@@ -463 +471 @@
 \label{s:BackquoteIdentifiers}
 
-\CFA accommodates keyword clashes with existing C variable-names by syntactic transformations using the \CFA backquote escape-mechanism:
+\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
+Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 int ®`®otype®`® = 3;                    §\C{// make keyword an identifier}§
 double ®`®forall®`® = 3.5;
 \end{cfa}
+
 Existing C programs with keyword clashes can be converted by enclosing keyword identifiers in backquotes, and eventually the identifier name can be changed to a non-keyword name.
-\VRef[Figure]{f:InterpositionHeaderFile} shows how clashes in C header files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©:
+\VRef[Figure]{f:HeaderFileInterposition} shows how clashes in existing C header-files (see~\VRef{s:StandardHeaders}) can be handled using preprocessor \newterm{interposition}: ©#include_next© and ©-I filename©.
+Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
 
 \begin{figure}
 \begin{cfa}
-// include file uses the CFA keyword "otype".
-#if ! defined( otype )                  §\C{// nesting ?}§
-#define otype ®`®otype®`®               §\C{// make keyword an identifier}§
+// include file uses the CFA keyword "with".
+#if ! defined( with )                   §\C{// nesting ?}§
+#define with ®`®with®`®                 §\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
-#endif // ! otype
-
-#®include_next® <bfd.h>                 §\C{// must have internal check for multiple expansion}§
-
-#if defined( otype ) && defined( __CFA_BFD_H__ )        §\C{// reset only if set}§
-#undef otype
+#endif
+
+®#include_next <bfdlink.h>              §\C{// must have internal check for multiple expansion}§
+®
+#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
+#undef with
 #undef __CFA_BFD_H__
-#endif // otype && __CFA_BFD_H__
-\end{cfa}
-\caption{Interposition of Header File}
-\label{f:InterpositionHeaderFile}
+#endif
+\end{cfa}
+\caption{Header-File Interposition}
+\label{f:HeaderFileInterposition}
 \end{figure}
 
 
-\section{Labelled Continue/Break}
+\section{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break}}{Labelled continue / break}}
 
 While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
 Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
-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}.
+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}, as in Java.
 For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
@@ -512 +523 @@
                         ®LF:® for ( ... ) {
                                 ®LW:® while ( ... ) {
-                                        ... break ®LC®; ...                     // terminate compound
-                                        ... break ®LS®; ...                     // terminate switch
-                                        ... break ®LIF®; ...                    // terminate if
-                                        ... continue ®LF;® ...   // resume loop
-                                        ... break ®LF®; ...                     // terminate loop
-                                        ... continue ®LW®; ...   // resume loop
-                                        ... break ®LW®; ...               // terminate loop
+                                        ... break ®LC®; ...             // terminate compound
+                                        ... break ®LS®; ...             // terminate switch
+                                        ... break ®LIF®; ...    // terminate if
+                                        ... continue ®LF;® ...  // resume loop
+                                        ... break ®LF®; ...             // terminate loop
+                                        ... continue ®LW®; ...  // resume loop
+                                        ... break ®LW®; ...             // terminate loop
                                 } // while
                         } // for
                 } else {
-                        ... break ®LIF®; ...                                     // terminate if
+                        ... break ®LIF®; ...                    // terminate if
                 } // if
         } // switch
@@ -564 +575 @@
                           LF: for ( ;; ) {
                                   LW: while ( 1 ) {
-                                                break LC;                       // terminate compound
-                                                break LS;                       // terminate switch
-                                                break LIF;                      // terminate if
-                                                continue LF;     // resume loop
-                                                break LF;                       // terminate loop
-                                                continue LW;     // resume loop
-                                                break LW;                 // terminate loop
+                                                break LC;               // terminate compound
+                                                break LS;               // terminate switch
+                                                break LIF;              // terminate if
+                                                continue LF;    // resume loop
+                                                break LF;               // terminate loop
+                                                continue LW;    // resume loop
+                                                break LW;               // terminate loop
                                         } // while
                                 } // for
                         } else {
-                                break LIF;                                       // terminate if
+                                break LIF;                               // terminate if
                         } // if
                 } // switch
@@ -613 +624 @@
 \item
 They cannot branch into a control structure.
-This restriction prevents missing initialization at the start of a control structure resulting in undefined behaviour.
+This restriction prevents missing declarations and/or initializations at the start of a control structure resulting in undefined behaviour.
 \end{itemize}
 The advantage of the labelled ©continue©/©break© is allowing static multi-level exits without having to use the ©goto© statement, and tying control flow to the target control structure rather than an arbitrary point in a program.
-Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
+Furthermore, the location of the label at the \emph{beginning} of the target control structure informs the reader (\Index{eye candy}) that complex control-flow is occurring in the body of the control structure.
 With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
 Finally, using an explicit target for the transfer instead of an implicit target allows new constructs to be added or removed without affecting existing constructs.
@@ -622 +633 @@
 
 
-\section{Switch Statement}
+\section{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
 
 C allows a number of questionable forms for the ©switch© statement:
@@ -663 +674 @@
         ®// open input file
 ®} else if ( argc == 2 ) {
-        ®// open input file
+        ®// open input file (duplicate)
 
 ®} else {
@@ -676 +687 @@
 \begin{cfa}
 switch ( i ) {
-  case 1: case 3: case 5:       // odd values
-        // same action
+  ®case 1: case 3: case 5:®     // odd values
+        // odd action
         break;
-  case 2: case 4: case 6:       // even values
-        // same action
+  ®case 2: case 4: case 6:®     // even values
+        // even action
         break;
 }
@@ -686 +697 @@
 However, this situation is handled in other languages without fall-through by allowing a list of case values.
 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 virtually all other programming languages with a ©switch© statement.
-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.
+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.
 
 \item
@@ -708 +719 @@
 The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
 The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
-The technical problem results from the inability to ensure allocation and initialization of variables when blocks are not entered at the beginning.
-Often transferring into a block can bypass variable declaration and/or its initialization, which results in subsequent errors.
-There are virtually no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
+The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
+There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
 Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
 \begin{cfa}
@@ -770 +780 @@
 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 help to put the \CFA changes to the ©switch© into perspective.
+These observations put into perspective the \CFA changes to the ©switch©.
 \begin{enumerate}
 \item
@@ -791 +801 @@
   case 7:
         ...
-        ®break®                                         §\C{// explicit end of switch}§
+        ®break®                                         §\C{// redundant explicit end of switch}§
   default:
         j = 3;
@@ -797 +807 @@
 \end{cfa}
 Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
-the implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
-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.
+An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
+An 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.
 As well, allowing an explicit ©break© from the ©choose© is a carry over from the ©switch© statement, and expected by C programmers.
 \item
@@ -827 +837 @@
 
 
-\section{Case Clause}
+\section{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
 
 C restricts the ©case© clause of a ©switch© statement to a single value.
@@ -903 +913 @@
 
 
+\section{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
+\label{s:WithClauseStatement}
+
+In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
+\begin{C++}
+class C {
+        int i, j;
+        int mem() {              ®// implicit "this" parameter
+®               i = 1;          ®// this->i
+®               j = 3;          ®// this->j
+®       }
+}
+\end{C++}
+Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
+\begin{cfa}
+struct S { int i, j; };
+int mem( S &this ) {    // explicit "this" parameter
+        ®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 (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
+\begin{cfa}
+int mem( S &this ) ®with this® {        // with clause
+        i = 1;                  ®// this.i
+®       j = 2;                  ®// this.j
+®}
+\end{cfa}
+which extends to multiple routine parameters:
+\begin{cfa}
+struct T { double m, n; };
+int mem2( S &this1, T &this2 ) ®with this1, this2® {
+        i = 1; j = 2;
+        m = 1.0; n = 2.0;
+}
+\end{cfa}
+
+The statement form is used within a block:
+\begin{cfa}
+int foo() {
+        struct S1 { ... } s1;
+        struct S2 { ... } s2;
+        ®with s1® {                     // with statement
+                // access fields of s1 without qualification
+                ®with s2® {  // nesting
+                        // access fields of s1 and s2 without qualification
+                }
+        }
+        ®with s1, s2® {
+                // access unambiguous fields of s1 and s2 without qualification
+        }
+}
+\end{cfa}
+
+When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
+For fields with the same name but different type, context/cast can be used to disambiguate.
+\begin{cfa}
+struct S { int i; int j; double m; } a, c;
+struct T { int i; int k; int m } b, c;
+®with a, b® {
+        j + k;                                          §\C{// unambiguous, unique names define unique types}§
+        i;                                                      §\C{// ambiguous, same name and type}§
+        a.i + b.i;                                      §\C{// unambiguous, qualification defines unique names}§
+        m;                                                      §\C{// ambiguous, same name and no context to define unique type}§
+        m = 5.0;                                        §\C{// unambiguous, same name and context defines unique type}§
+        m = 1;                                          §\C{// unambiguous, same name and context defines unique type}§
+}
+®with c® { ... }                                §\C{// ambiguous, same name and no context}§
+®with (S)c® { ... }                             §\C{// unambiguous, same name and cast defines unique type}§
+\end{cfa}
+
+
 \section{Exception Handling}
+\label{s:ExceptionHandling}
 
 Exception handling provides two mechanism: change of control flow from a raise to a handler, and communication from the raise to the handler.
-\begin{cfa}
-exception void h( int i );
-exception int h( int i, double d );
-
+Transfer of control can be local, within a routine, or non-local, among routines.
+Non-local transfer can cause stack unwinding, i.e., non-local routine termination, depending on the kind of raise.
+\begin{cfa}
+exception_t E {};                               §\C{// exception type}§
 void f(...) {
-        ... throw h( 3 );
-        ... i = resume h( 3, 5.1 );
-}
-
+        ... throw E{}; ...                      §\C{// termination}§
+        ... throwResume E{}; ...        §\C{// resumption}§
+}
 try {
         f(...);
-} catch h( int w ) {
-        // reset
-} resume h( int p, double x ) {
-        return 17;  // recover
+} catch( E e : §boolean-predicate§ ) {                  §\C{// termination handler}§
+        // recover and continue
+} catchResume( E e : §boolean-predicate§ ) {    §\C{// resumption handler}§
+        // repair and return
 } finally {
-}
-\end{cfa}
-So the type raised would be the mangled name of the exception prototype and that name would be matched at the handler clauses by comparing the strings.
-The arguments for the call would have to be packed in a message and unpacked at handler clause and then a call made to the handler.
+        // always executed
+}
+\end{cfa}
+The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©.
+Then the exception type must match along with any additonal predicate must be true.
+The ©catch© and ©catchResume© handlers may appear in any oder.
+However, the ©finally© clause must appear at the end of the ©try© statement.
 
 
@@ -1136 +1223 @@
 
 
-\section{Pointer/Reference}
+\section{Exponentiation Operator}
+
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
+
+As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $b^{-e}=1/b^e$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
+Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
+256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
+
+
+\section{Pointer / Reference}
 
 C provides a \newterm{pointer type};
@@ -1144 +1252 @@
 An integer constant expression with the value 0, or such an expression cast to type ©void *©, is called a \newterm{null-pointer constant}.\footnote{
 One way to conceptualize the null pointer is that no variable is placed at this address, so the null-pointer address can be used to denote an uninitialized pointer/reference object;
-\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.}
+\ie the null pointer is guaranteed to compare unequal to a pointer to any object or routine.
+In general, a value with special meaning among a set of values is called a \emph{\Index{sentinel value}}, \eg ©-1© as a return code value.}
 An address is \newterm{sound}, if it points to a valid memory location in scope, \ie within the program's execution-environment and has not been freed.
 Dereferencing an \newterm{unsound} address, including the null pointer, is \Index{undefined}, often resulting in a \Index{memory fault}.
@@ -1179 +1288 @@
 \hline
 \begin{cfa}
-lda             r1,100                  // load address of x
-ld               r2,(r1)                  // load value of x
-lda             r3,104                  // load address of y
-st               r2,(r3)                  // store x into y
+lda             r1,100  // load address of x
+ld               r2,(r1)          // load value of x
+lda             r3,104  // load address of y
+st               r2,(r3)          // store x into y
 \end{cfa}
 &
 \begin{cfa}
 
-ld              r2,(100)                // load value of x
-
-st              r2,(104)                // store x into y
+ld              r2,(100)        // load value of x
+
+st              r2,(104)        // store x into y
 \end{cfa}
 \end{tabular}
@@ -1485 +1594 @@
 
 \item
-lvalue to reference conversion: \lstinline[deletekeywords={lvalue}]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
+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 ); // lvalue variable (int) convert to reference (int &)
@@ -2594 +2703 @@
 \begin{cfa}[belowskip=0pt]
 char store[®sepSize®];                                          §\C{// sepSize is the maximum separator size}§
-strcpy( store, sepGet( sout ) );
-sepSet( sout, "_" );
+strcpy( store, sepGet( sout ) );                          §\C{// copy current separator}§
+sepSet( sout, "_" );                                            §\C{// change separator to underscore}§
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
@@ -2602 +2711 @@
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
-sepSet( sout, store );
+sepSet( sout, store );                                          §\C{// change separator back to original}§
 sout | 1 | 2 | 3 | endl;
 \end{cfa}
@@ -3159 +3268 @@
 \Indexc{gcc} provides ©typeof© to declare a secondary variable from a primary variable.
 \CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
-Only for overloaded routines with the same return type is variable type-inferencing possible.
+Only for overloaded routines \emph{with the same return type} is variable type-inferencing possible.
 Finally, ©auto© presents the programming problem of tracking down a type when the type is actually needed.
 For example, given
@@ -5258 +5367 @@
 
 
-\section{\CFA Keywords}
+\section{\texorpdfstring{\CFA Keywords}{Cforall Keywords}}
 \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©                 \\
+©with©                  \\
 ©zero_t©                \\
 \end{tabular}
@@ -5330 +5445 @@
 g( p1, p2 ) int p1, p2;                 §\C{// int g( int p1, int p2 );}§
 \end{cfa}
-\CFA supports K\&R routine definitions:
+\CFA continues to support K\&R routine definitions:
 \begin{cfa}
 f( a, b, c )                                    §\C{// default int return}§
@@ -5471 +5586 @@
 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{quote2}
-\lstset{deletekeywords={float}}
-\begin{tabular}{@{}llll|l@{}}
-\multicolumn{4}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
+\begin{tabular}{@{}lllll|l@{}}
+\multicolumn{5}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
 \hline
 \begin{tabular}{@{}l@{}}
@@ -5481 +5595 @@
 \Indexc{errno.h}                \\
 \Indexc{fenv.h}                 \\
-\Indexc{float.h}                \\
-\Indexc{inttypes.h}             \\
-\Indexc{iso646.h}               \\
+\Indexc[deletekeywords=float]{float.h} \\
 \end{tabular}
 &
 \begin{tabular}{@{}l@{}}
+\Indexc{inttypes.h}             \\
+\Indexc{iso646.h}               \\
 \Indexc{limits.h}               \\
 \Indexc{locale.h}               \\
 \Indexc{math.h}                 \\
 \Indexc{setjmp.h}               \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
 \Indexc{signal.h}               \\
 \Indexc{stdalign.h}             \\
 \Indexc{stdarg.h}               \\
 \Indexc{stdatomic.h}    \\
+\Indexc{stdbool.h}              \\
+\Indexc{stddef.h}               \\
 \end{tabular}
 &
 \begin{tabular}{@{}l@{}}
-\Indexc{stdbool.h}              \\
-\Indexc{stddef.h}               \\
 \Indexc{stdint.h}               \\
 \Indexc{stdio.h}                \\
@@ -5515 +5632 @@
 \Indexc{wctype.h}               \\
                                                 \\
-                                                \\
-                                                \\
 \end{tabular}
 &
@@ -5522 +5637 @@
 \Indexc{unistd.h}               \\
 \Indexc{gmp.h}                  \\
-                                                \\
-                                                \\
                                                 \\
                                                 \\
@@ -5563 +5676 @@
 The table shows allocation routines supporting different combinations of storage-management capabilities:
 \begin{center}
-\begin{tabular}{@{}lr|l|l|l|l@{}}
-                &                                       & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
+\begin{tabular}{@{}r|r|l|l|l|l@{}}
+\multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
 \hline
 C               & ©malloc©                      & no                    & no            & no            & no    \\
@@ -5571 +5684 @@
                 & ©memalign©            & no                    & no            & yes           & no    \\
                 & ©posix_memalign©      & no                    & no            & yes           & no    \\
+\hline
 C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
+\hline
 \CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
                 & ©align_alloc©         & no/yes                & no            & yes           & yes   \\