Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/user/user.tex

    rc4e3419c r128c4e4  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Mon Feb 15 13:48:53 2021
    14 %% Update Count     : 4452
     13%% Last Modified On : Mon Oct  5 08:57:29 2020
     14%% Update Count     : 3998
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    3737\usepackage{mathptmx}                                   % better math font with "times"
    3838\usepackage[usenames]{color}
    39 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
    40 \usepackage{breakurl}
    41 
    42 \renewcommand\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
    43 
    44 \usepackage[pagewise]{lineno}
    45 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
    46 \usepackage[firstpage]{draftwatermark}
    47 \SetWatermarkLightness{0.9}
    48 
    49 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
    50 % removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
    51 % AFTER HYPERREF.
    52 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
    53 
    54 \setlength{\topmargin}{-0.45in}                                                 % move running title into header
    55 \setlength{\headsep}{0.25in}
    56 
    57 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    58 
    5939\newcommand{\CFALatin}{}
    6040% inline code ©...© (copyright symbol) emacs: C-q M-)
    … …  
    6646% math escape $...$ (dollar symbol)
    6747\input{common}                                          % common CFA document macros
     48\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
     49\usepackage{breakurl}
     50
     51\renewcommand\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
     52
     53\usepackage[pagewise]{lineno}
     54\renewcommand{\linenumberfont}{\scriptsize\sffamily}
     55\usepackage[firstpage]{draftwatermark}
     56\SetWatermarkLightness{0.9}
     57
     58% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
     59% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
     60% AFTER HYPERREF.
     61\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
     62
     63\setlength{\topmargin}{-0.45in}                                                 % move running title into header
     64\setlength{\headsep}{0.25in}
     65
     66%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     67
    6868\CFAStyle                                                                                               % use default CFA format-style
    69 \lstset{language=CFA}                                                                   % CFA default lnaguage
    7069\lstnewenvironment{C++}[1][]                            % use C++ style
    71 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}}
     70{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
    7271{}
    7372
    … …  
    8281\newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
    8382\newcommand{\R}[1]{\Textbf{#1}}
    84 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}
    8583\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
    8684\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
    … …  
    105103
    106104\author{
    107 \huge \CFA Team (past and present) \medskip \\
    108 \Large Andrew Beach, Richard Bilson, Michael Brooks, Peter A. Buhr, Thierry Delisle, \smallskip \\
    109 \Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Colby Parsons, Rob Schluntz, \smallskip \\
    110 \Large Fangren Yu, Mubeen Zulfiqar
     105\huge \CFA Team \medskip \\
     106\Large Andrew Beach, Richard Bilson, Peter A. Buhr, Thierry Delisle, \smallskip \\
     107\Large Glen Ditchfield, Rodolfo G. Esteves, Aaron Moss, Rob Schluntz
    111108}% author
    112109
    … …  
    129126\vspace*{\fill}
    130127\noindent
    131 \copyright\,2016, 2018, 2021 \CFA Project \\ \\
     128\copyright\,2016 \CFA Project \\ \\
    132129\noindent
    133130This work is licensed under the Creative Commons Attribution 4.0 International License.
    … …  
    147144\section{Introduction}
    148145
    149 \CFA{}\index{cforall@\CFA}\footnote{Pronounced ``\Index*{C-for-all}'', and written \CFA, CFA, or \CFL.} is a modern general-purpose concurrent programming-language, designed as an evolutionary step forward for the C programming language.
     146\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.
    150147The syntax of \CFA builds from C and should look immediately familiar to C/\Index*[C++]{\CC{}} programmers.
    151148% Any language feature that is not described here can be assumed to be using the standard \Celeven syntax.
    152 \CFA adds many modern features that directly lead to increased \emph{\Index{safety}} and \emph{\Index{productivity}}, while maintaining interoperability with existing C programs and achieving similar performance.
     149\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.
    153150Like 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.
    154151The primary new features include polymorphic routines and types, exceptions, concurrency, and modules.
    … …  
    160157instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features.
    161158As well, new programs can be written in \CFA using a combination of C and \CFA features.
    162 In many ways, \CFA is to C as \Index{Scala}~\cite{Scala} is to Java, providing a vehicle for new typing and control-flow capabilities on top of a highly popular programming language allowing immediate dissemination.
    163159
    164160\Index*[C++]{\CC{}}~\cite{c++:v1} had a similar goal 30 years ago, allowing object-oriented programming to be incrementally added to C.
    … …  
    169165For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result.
    170166\begin{center}
    171 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
    172 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}}   & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
    173 \begin{cfa}
    174 #include <stdio.h>$\indexc{stdio.h}$
     167\begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
     168\multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
     169\begin{cfa}
     170#include <stdio.h>§\indexc{stdio.h}§
    175171
    176172int main( void ) {
    177173        int x = 0, y = 1, z = 2;
    178         @printf( "%d %d %d\n", x, y, z );@
     174        ®printf( "%d %d %d\n", x, y, z );®
    179175}
    180176\end{cfa}
    181177&
    182178\begin{cfa}
    183 #include <fstream>$\indexc{fstream}$
     179#include <fstream>§\indexc{fstream}§
    184180
    185181int main( void ) {
    186182        int x = 0, y = 1, z = 2;
    187         @sout | x | y | z;@$\indexc{sout}$
     183        ®sout | x | y | z;®§\indexc{sout}§
    188184}
    189185\end{cfa}
    190186&
    191187\begin{cfa}
    192 #include <iostream>$\indexc{iostream}$
     188#include <iostream>§\indexc{iostream}§
    193189using namespace std;
    194190int main() {
    195191        int x = 0, y = 1, z = 2;
    196         @cout<<x<<" "<<y<<" "<<z<<endl;@
     192        ®cout<<x<<" "<<y<<" "<<z<<endl;®
    197193}
    198194\end{cfa}
    199195\end{tabular}
    200196\end{center}
    201 While \CFA I/O \see{\VRef{s:StreamIOLibrary}} looks similar to \Index*[C++]{\CC{}}, there are important differences, such as automatic spacing between variables and an implicit newline at the end of the expression list, similar to \Index*{Python}~\cite{Python}.
     197While 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}).
    202198
    203199
    … …  
    214210\section{Why fix C?}
    215211
    216 The C programming language is a foundational technology for modern computing with billions of lines of code implementing everything from hobby projects to commercial operating-systems.
     212The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating-systems.
    217213This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
    218214Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
    219 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is the only language of choice.
    220 The TIOBE index~\cite{TIOBE} for February 2021 ranks the top six most \emph{popular} programming languages as C 17.4\%, \Index*{Java} 12\%, Python 12\%, \Index*[C++]{\CC{}} 7.6\%, \Csharp 4\%, Visual Basic 3.8\% = 56.8\%, where the next 50 languages are less than 2\% each, with a long tail.
     215For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
     216The TIOBE index~\cite{TIOBE} for February 2020 ranks the top six most \emph{popular} programming languages as \Index*{Java} 17.4\%, C 16.8\%, Python 9.3\%, \Index*[C++]{\CC{}} 6.2\%, \Csharp 5.9\%, Visual Basic 5.9\% = 61.5\%, where the next 50 languages are less than 2\% each, with a long tail.
    221217The top 4 rankings over the past 35 years are:
    222218\begin{center}
    223219\setlength{\tabcolsep}{10pt}
    224220\begin{tabular}{@{}rcccccccc@{}}
    225                 & 2021  & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986  \\ \hline
    226 \R{C}   & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\
    227 Java    & 2             & 1             & 1             & 2             & 3             & 28    & -             & -             \\
    228 Python  & 3             & 5             & 6             & 7             & 23    & 13    & -             & -             \\
    229 \CC             & 4             & 3             & 3             & 3             & 2             & 2             & 2             & 8             \\
     221                & 2020  & 2015  & 2010  & 2005  & 2000  & 1995  & 1990  & 1985  \\ \hline
     222Java    & 1             & 2             & 1             & 2             & 3             & -             & -             & -             \\
     223\R{C}   & \R{2} & \R{1} & \R{2} & \R{1} & \R{1} & \R{2} & \R{1} & \R{1} \\
     224Python  & 3             & 7             & 6             & 6             & 22    & 21    & -             & -             \\
     225\CC             & 4             & 4             & 4             & 3             & 2             & 1             & 2             & 12    \\
    230226\end{tabular}
    231227\end{center}
    … …  
    236232As stated, the goal of the \CFA project is to engineer modern language-features into C in an evolutionary rather than revolutionary way.
    237233\CC~\cite{C++14,C++} is an example of a similar project;
    238 however, it largely extended the C language, and did not address many of C's existing problems.\footnote{%
     234however, it largely extended the C language, and did not address most of C's existing problems.\footnote{%
    239235Two 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.}
    240236\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.
    … …  
    245241
    246242The 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 adding modern language-features.
    247 To achieve these goals required a significant engineering exercise, \ie ``thinking \emph{inside} the C box''.
    248 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern language.
     243To achieve these goals required a significant engineering exercise, where we had to ``think inside the existing C box''.
     244Without these significant extension to C, it is unable to cope with the needs of modern programming problems and programmers;
     245as a result, it will fade into disuse.
     246Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
    249247While \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.
    250248While 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.
    … …  
    253251\section{History}
    254252
    255 The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \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{}}}.
     253The \CFA project started with \Index*{Dave Till}\index{Till, Dave}'s \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.
     254(See~\cite{Werther96} for similar work in \Index*[C++]{\CC{}}.)
    256255The first \CFA implementation of these extensions was by \Index*{Rodolfo Esteves}\index{Esteves, Rodolfo}~\cite{Esteves04}.
    257256
    258257The 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):
    259258\begin{cfa}
    260 @forall( otype T )@ T identity( T val ) { return val; }
    261 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
     259®forall( otype T )® T identity( T val ) { return val; }
     260int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§
    262261\end{cfa}
    263262% extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
    264263\CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}.
    265264However, at that time, there was little interesting in extending C, so work did not continue.
    266 As the saying goes, ``\Index*{What goes around, comes around.}'', and there is now renewed interest in the C programming language because of the legacy code-base, so the \CFA project was restarted in 2015.
     265As 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.
    267266
    268267
    … …  
    274273This feature allows \CFA programmers to take advantage of the existing panoply of C libraries to access thousands of external software features.
    275274Language developers often state that adequate \Index{library support} takes more work than designing and implementing the language itself.
    276 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 zero or very low cost.
     275Fortunately, \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.
    277276Hence, \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.
    278277
    … …  
    287286
    288287double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
    289 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$
     288double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§
    290289\end{cfa}
    291290which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
    … …  
    296295
    297296forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
    298         T * result = bsearch( key, arr, size ); $\C{// call first version}$
    299         return result ? result - arr : size; } $\C{// pointer subtraction includes sizeof(T)}$
    300 
    301 double * val = bsearch( 5.0, vals, 10 ); $\C{// selection based on return type}$
     297        T * result = bsearch( key, arr, size ); §\C{// call first version}§
     298        return result ? result - arr : size; } §\C{// pointer subtraction includes sizeof(T)}§
     299
     300double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§
    302301int posn = bsearch( 5.0, vals, 10 );
    303302\end{cfa}
    … …  
    311310\begin{cfa}
    312311forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
    313 int * ip = malloc(); $\C{// select type and size from left-hand side}$
     312int * ip = malloc(); §\C{// select type and size from left-hand side}§
    314313double * dp = malloc();
    315314struct S {...} * sp = malloc();
    … …  
    320319However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
    321320For 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©.
    322 Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
    323 \begin{cfa}
    324 char @abs@( char );
    325 extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$
    326 long int @abs@( long int );
    327 long long int @abs@( long long int );
    328 float @abs@( float );
    329 double @abs@( double );
    330 long double @abs@( long double );
    331 float _Complex @abs@( float _Complex );
    332 double _Complex @abs@( double _Complex );
    333 long double _Complex @abs@( long double _Complex );
    334 \end{cfa}
    335 The problem is \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default).
    336 Overloaded names must use \newterm{name mangling}\index{mangling!name} to create unique names that are different from unmangled C names.
    337 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.
    338 The only way around this problem is C's approach of creating unique names for each pairing of operation and type.
    339 
    340 This example illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
     321Whereas, \CFA wraps each of these routines into ones with the overloaded name ©abs©:
     322\begin{cfa}
     323char ®abs®( char );
     324extern "C" { int ®abs®( int ); } §\C{// use default C routine for int}§
     325long int ®abs®( long int );
     326long long int ®abs®( long long int );
     327float ®abs®( float );
     328double ®abs®( double );
     329long double ®abs®( long double );
     330float _Complex ®abs®( float _Complex );
     331double _Complex ®abs®( double _Complex );
     332long double _Complex ®abs®( long double _Complex );
     333\end{cfa}
     334The problem is the name clash between the library routine ©abs© and the \CFA names ©abs©.
     335Hence, names appearing in an ©extern "C"© block have \newterm*{C linkage}.
     336Then overloading polymorphism uses a mechanism called \newterm{name mangling}\index{mangling!name} to create unique names that are different from C names, which are not mangled.
     337Hence, 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.
     338There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and types.
     339
     340This example strongly illustrates a core idea in \CFA: \emph{the \Index{power of a name}}.
    341341The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
    342342Hence, knowing the name ©abs© is sufficient to apply it to any type where it is applicable.
    … …  
    344344
    345345
    346 \section{\CFA Compilation}
     346\section[Compiling a CFA Program]{Compiling a \CFA Program}
    347347
    348348The command ©cfa© is used to compile a \CFA program and is based on the \Index{GNU} \Indexc{gcc} command, \eg:
    349349\begin{cfa}
    350 cfa$\indexc{cfa}\index{compilation!cfa@©cfa©}$ [ gcc/$\CFA{}$-options ] [ C/$\CFA{}$ source-files ] [ assembler/loader files ]
    351 \end{cfa}
    352 There is no ordering among options (flags) and files, unless an option has an argument, which must appear immediately after the option possibly with or without a space separating option and argument.
    353 
    354 \CFA has the following ©gcc© flags turned on:
    355 \begin{description}[topsep=0pt]
     350cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] [ C/§\CFA{}§ source-files ] [ assembler/loader files ]
     351\end{cfa}
     352\CFA programs having the following ©gcc© flags turned on:
     353\begin{description}
    356354\item
    357355\Indexc{-std=gnu11}\index{compilation option!-std=gnu11@{©-std=gnu11©}}
    … …  
    361359Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
    362360\end{description}
    363 
    364 \CFA has the following new options:
    365 \begin{description}[topsep=0pt]
     361The following new \CFA options are available:
     362\begin{description}
    366363\item
    367364\Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
    368 Only the C preprocessor (flag ©-E©) 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.
     365Only 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.
    369366The generated code starts with the standard \CFA \Index{prelude}.
    370 
    371 \item
    372 \Indexc{-XCFA}\index{compilation option!-XCFA@©-XCFA©}
    373 Pass next flag as-is to the ©cfa-cpp© translator (see details below).
    374367
    375368\item
    376369\Indexc{-debug}\index{compilation option!-debug@©-debug©}
    377370The program is linked with the debugging version of the runtime system.
    378 The debug version performs runtime checks to aid the debugging phase of a \CFA program, but can substantially slow program execution.
     371The debug version performs runtime checks to help during the debugging phase of a \CFA program, but can substantially slow program execution.
    379372The runtime checks should only be removed after the program is completely debugged.
    380373\textbf{This option is the default.}
    … …  
    406399\item
    407400\Indexc{-no-include-stdhdr}\index{compilation option!-no-include-stdhdr@©-no-include-stdhdr©}
    408 Do not supply ©extern "C"© wrappers for \Celeven standard include files \see{\VRef{s:StandardHeaders}}.
     401Do not supply ©extern "C"© wrappers for \Celeven standard include files (see~\VRef{s:StandardHeaders}).
    409402\textbf{This option is \emph{not} the default.}
    410403\end{comment}
    … …  
    437430\begin{cfa}
    438431#ifndef __CFORALL__
    439 #include <stdio.h>$\indexc{stdio.h}$ $\C{// C header file}$
     432#include <stdio.h>§\indexc{stdio.h}§ §\C{// C header file}§
    440433#else
    441 #include <fstream>$\indexc{fstream}$ $\C{// \CFA header file}$
     434#include <fstream>§\indexc{fstream}§ §\C{// \CFA header file}§
    442435#endif
    443436\end{cfa}
    … …  
    445438
    446439The \CFA translator has multiple steps.
    447 The following flags control how the translator works, the stages run, and printing within a stage.
     440The following flags control how the tranlator works, the stages run, and printing within a stage.
    448441The majority of these flags are used by \CFA developers, but some are occasionally useful to programmers.
    449 Each option must be escaped with \Indexc{-XCFA}\index{translator option!-XCFA@{©-XCFA©}} to direct it to the compiler step, similar to the ©-Xlinker© flag for the linker, \eg:
    450 \begin{lstlisting}[language=sh]
    451 cfa $test$.cfa -CFA -XCFA -p # print translated code without printing the standard prelude
    452 cfa $test$.cfa -XCFA -P -XCFA parse -XCFA -n # show program parse without prelude
    453 \end{lstlisting}
    454442\begin{description}[topsep=5pt,itemsep=0pt,parsep=0pt]
    455443\item
    456 \Indexc{-c}\index{translator option!-c@{©-c©}}, \Indexc{--colors}\index{translator option!--colors@{©--colors©}} \, diagnostic color: ©never©, ©always©, \lstinline[deletekeywords=auto]{auto}
    457 \item
    458 \Indexc{-g}\index{translator option!-g@{©-g©}}, \Indexc{--gdb}\index{translator option!--gdb@{©--gdb©}} \, wait for gdb to attach
    459 \item
    460 \Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print translator help message
    461 \item
    462 \Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate ©libcfa.c©
     444\Indexc{-h}\index{translator option!-h@{©-h©}}, \Indexc{--help}\index{translator option!--help@{©--help©}} \, print help message
     445\item
     446\Indexc{-l}\index{translator option!-l@{©-l©}}, \Indexc{--libcfa}\index{translator option!--libcfa@{©--libcfa©}} \, generate libcfa.c
    463447\item
    464448\Indexc{-L}\index{translator option!-L@{©-L©}}, \Indexc{--linemarks}\index{translator option!--linemarks@{©--linemarks©}} \, generate line marks
    … …  
    470454\Indexc{-n}\index{translator option!-n@{©-n©}}, \Indexc{--no-prelude}\index{translator option!--no-prelude@{©--no-prelude©}} \, do not read prelude
    471455\item
    472 \Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, do not generate prelude prototypes $\Rightarrow$ prelude not printed
    473 \item
    474 \Indexc{-d}\index{translator option!-d@{©-d©}}, \Indexc{--deterministic-out}\index{translator option!--deterministic-out@{©--deterministic-out©}} \, only print deterministic output
     456\Indexc{-p}\index{translator option!-p@{©-p©}}, \Indexc{--prototypes}\index{translator option!--prototypes@{©--prototypes©}} \, generate prototypes for prelude functions
    475457\item
    476458\Indexc{-P}\index{translator option!-P@{©-P©}}, \Indexc{--print}\index{translator option!--print@{©--print©}} \, one of:
    477459\begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
    478460\item
     461\Indexc{altexpr}\index{translator option!-P@{©-P©}!©altexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, alternatives for expressions
     462\item
    479463\Indexc{ascodegen}\index{translator option!-P@{©-P©}!©ascodegen©}\index{translator option!--print@{©-print©}!©ascodegen©} \, as codegen rather than AST
    480464\item
     465\Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, AST after parsing
     466\item
     467\Indexc{astdecl}\index{translator option!-P@{©-P©}!©astdecl©}\index{translator option!--print@{©-print©}!©astdecl©} \, AST after declaration validation pass
     468\item
    481469\Indexc{asterr}\index{translator option!-P@{©-P©}!©asterr©}\index{translator option!--print@{©-print©}!©asterr©} \, AST on error
    482470\item
     471\Indexc{astexpr}\index{translator option!-P@{©-P©}!©astexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, AST after expression analysis
     472\item
     473\Indexc{astgen}\index{translator option!-P@{©-P©}!©astgen©}\index{translator option!--print@{©-print©}!©astgen©} \, AST after instantiate generics
     474\item
     475\Indexc{box}\index{translator option!-P@{©-P©}!©box©}\index{translator option!--print@{©-print©}!©box©} \, before box step
     476\item
     477\Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, after ctor/dtor are replaced
     478\item
     479\Indexc{codegen}\index{translator option!-P@{©-P©}!©codegen©}\index{translator option!--print@{©-print©}!©codegen©} \, before code generation
     480\item
    483481\Indexc{declstats}\index{translator option!-P@{©-P©}!©declstats©}\index{translator option!--print@{©-print©}!©declstats©} \, code property statistics
    484482\item
    485483\Indexc{parse}\index{translator option!-P@{©-P©}!©parse©}\index{translator option!--print@{©-print©}!©parse©} \, yacc (parsing) debug information
    486484\item
    487 \Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ©ascodegen© flag
     485\Indexc{pretty}\index{translator option!-P@{©-P©}!©pretty©}\index{translator option!--print@{©-print©}!©pretty©} \, prettyprint for ascodegen flag
     486\item
     487\Indexc{resolver}\index{translator option!-P@{©-P©}!©resolver©}\index{translator option!--print@{©-print©}!©resolver©} \, before resolver step
    488488\item
    489489\Indexc{rproto}\index{translator option!-P@{©-P©}!©rproto©}\index{translator option!--print@{©-print©}!©rproto©} \, resolver-proto instance
    … …  
    491491\Indexc{rsteps}\index{translator option!-P@{©-P©}!©rsteps©}\index{translator option!--print@{©-print©}!©rsteps©} \, resolver steps
    492492\item
     493\Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, symbol table events
     494\item
    493495\Indexc{tree}\index{translator option!-P@{©-P©}!©tree©}\index{translator option!--print@{©-print©}!©tree©} \, parse tree
    494496\item
    495 \Indexc{ast}\index{translator option!-P@{©-P©}!©ast©}\index{translator option!--print@{©-print©}!©ast©} \, AST after parsing
    496 \item
    497 \Indexc{symevt}\index{translator option!-P@{©-P©}!©symevt©}\index{translator option!--print@{©-print©}!©symevt©} \, symbol table events
    498 \item
    499 \Indexc{altexpr}\index{translator option!-P@{©-P©}!©altexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, alternatives for expressions
    500 \item
    501 \Indexc{astdecl}\index{translator option!-P@{©-P©}!©astdecl©}\index{translator option!--print@{©-print©}!©astdecl©} \, AST after declaration validation pass
    502 \item
    503 \Indexc{resolver}\index{translator option!-P@{©-P©}!©resolver©}\index{translator option!--print@{©-print©}!©resolver©} \, before resolver step
    504 \item
    505 \Indexc{astexpr}\index{translator option!-P@{©-P©}!©astexpr©}\index{translator option!--print@{©-print©}!©altexpr©} \, AST after expression analysis
    506 \item
    507 \Indexc{ctordtor}\index{translator option!-P@{©-P©}!©ctordtor©}\index{translator option!--print@{©-print©}!©ctordtor©} \, after ctor/dtor are replaced
    508 \item
    509497\Indexc{tuple}\index{translator option!-P@{©-P©}!©tuple©}\index{translator option!--print@{©-print©}!©tuple©} \, after tuple expansion
    510 \item
    511 \Indexc{astgen}\index{translator option!-P@{©-P©}!©astgen©}\index{translator option!--print@{©-print©}!©astgen©} \, AST after instantiate generics
    512 \item
    513 \Indexc{box}\index{translator option!-P@{©-P©}!©box©}\index{translator option!--print@{©-print©}!©box©} \, before box step
    514 \item
    515 \Indexc{codegen}\index{translator option!-P@{©-P©}!©codegen©}\index{translator option!--print@{©-print©}!©codegen©} \, before code generation
    516498\end{description}
    517499\item
    518500\Indexc{--prelude-dir} <directory> \, prelude directory for debug/nodebug
    519501\item
    520 \Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information: ©counters©, ©heap©, ©time©, ©all©, ©none©
     502\Indexc{-S}\index{translator option!-S@{©-S©}!©counters,heap,time,all,none©}, \Indexc{--statistics}\index{translator option!--statistics@{©--statistics©}!©counters,heap,time,all,none©} <option-list> \, enable profiling information:
     503\begin{description}[topsep=0pt,itemsep=0pt,parsep=0pt]
     504\item
     505\Indexc{counters,heap,time,all,none}
     506\end{description}
    521507\item
    522508\Indexc{-t}\index{translator option!-t@{©-t©}}, \Indexc{--tree}\index{translator option!--tree@{©--tree©}} build in tree
    … …  
    527513\label{s:BackquoteIdentifiers}
    528514
    529 \CFA introduces several new keywords \see{\VRef{s:CFAKeywords}} that can clash with existing C variable-names in legacy code.
     515\CFA introduces several new keywords (see \VRef{s:CFAKeywords}) that can clash with existing C variable-names in legacy code.
    530516Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
    531517\begin{cfa}
    532 int @``@otype = 3; $\C{// make keyword an identifier}$
    533 double @``@forall = 3.5;
     518int ®``®otype = 3; §\C{// make keyword an identifier}§
     519double ®``®forall = 3.5;
    534520\end{cfa}
    535521
    536522Existing 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.
    537 \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©.
     523\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©.
    538524Several common C header-files with keyword clashes are fixed in the standard \CFA header-library, so there is a seamless programming-experience.
    539525
    … …  
    541527\begin{cfa}
    542528// include file uses the CFA keyword "with".
    543 #if ! defined( with )                                                   $\C{// nesting ?}$
    544 #define with @``@with                                                   $\C{// make keyword an identifier}$
     529#if ! defined( with ) §\C{// nesting ?}§
     530#define with ®``®with §\C{// make keyword an identifier}§
    545531#define __CFA_BFD_H__
    546532#endif
    547 $\R{\#include\_next} <bfdlink.h>$                               $\C{// must have internal check for multiple expansion}$
    548 #if defined( with ) && defined( __CFA_BFD_H__ ) $\C{// reset only if set}$
     533§{\color{red}\#\textbf{include\_next} <bfdlink.h>}§ §\C{// must have internal check for multiple expansion}§
     534#if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
    549535#undef with
    550536#undef __CFA_BFD_H__
    … …  
    558544\section{Constant Underscores}
    559545
    560 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
    561 \begin{cfa}
    562 2@_@147@_@483@_@648; $\C{// decimal constant}$
    563 56@_@ul; $\C{// decimal unsigned long constant}$
    564 0@_@377; $\C{// octal constant}$
    565 0x@_@ff@_@ff; $\C{// hexadecimal constant}$
    566 0x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$
    567 3.141@_@592@_@654; $\C{// floating constant}$
    568 10@_@e@_@+1@_@00; $\C{// floating constant}$
    569 0x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$
    570 0x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$
    571 L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$
     546Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore}, \eg:
     547\begin{cfa}
     5482®_®147®_®483®_®648; §\C{// decimal constant}§
     54956®_®ul; §\C{// decimal unsigned long constant}§
     5500®_®377; §\C{// octal constant}§
     5510x®_®ff®_®ff; §\C{// hexadecimal constant}§
     5520x®_®ef3d®_®aa5c; §\C{// hexadecimal constant}§
     5533.141®_®592®_®654; §\C{// floating constant}§
     55410®_®e®_®+1®_®00; §\C{// floating constant}§
     5550x®_®ff®_®ff®_®p®_®3; §\C{// hexadecimal floating}§
     5560x®_®1.ffff®_®ffff®_®p®_®128®_®l; §\C{// hexadecimal floating long constant}§
     557L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§; §\C{// wide character constant}§
    572558\end{cfa}
    573559The rules for placement of underscores are:
    … …  
    588574It is significantly easier to read and enter long constants when they are broken up into smaller groupings (many cultures use comma and/or period among digits for the same purpose).
    589575This extension is backwards compatible, matches with the use of underscore in variable names, and appears in \Index*{Ada} and \Index*{Java} 8.
    590 \CC uses the single quote (©'©) as a separator, restricted within a sequence of digits, \eg ©0xaa©©'©©ff©, ©3.141©©'©©592E1©©'©©1©.
    591576
    592577
    593578\section{Exponentiation Operator}
    594579
    595 C, \CC, and Java (and other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation.
    596 \CFA extends the basic operators with the exponentiation operator ©?©\R{©\\©}©?©\index{?\\?@©?@\@?©} and ©?©\R{©\\©}©=?©\index{?\\=?@©@\@=?©}, as in, ©x ©\R{©\\©}© y© and ©x ©\R{©\\©}©= y©, which means $x^y$ and $x \leftarrow x^y$.
    597 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©.
     580C, \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(x,y)}, to perform the exponentiation operation.
     581\CFA extends the basic operators with the exponentiation operator ©?®\®?©\index{?\\?@©?®\®?©} and ©?\=?©\index{?\\=?@©®\®=?©}, as in, ©x ®\® y© and ©x ®\®= y©, which means $x^y$ and $x \leftarrow x^y$.
     582The 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)©.
    598583
    599584There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
    … …  
    602587Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
    603588\begin{cfa}
    604 sout | 1 @\@ 0 | 1 @\@ 1 | 2 @\@ 8 | -4 @\@ 3 | 5 @\@ 3 | 5 @\@ 32 | 5L @\@ 32 | 5L @\@ 64 | -4 @\@ -3 | -4.0 @\@ -3 | 4.0 @\@ 2.1
    605            | (1.0f+2.0fi) @\@ (3.0f+2.0fi);
    606 1 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@ -0.015625 18.3791736799526 0.264715-1.1922i
     589sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
     590           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
     5911 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
    607592\end{cfa}
    608593Note, ©5 \ 32© and ©5L \ 64© overflow, and ©-4 \ -3© is a fraction but stored in an integer so all three computations generate an integral zero.
    609 Because exponentiation has higher priority than ©+©, parenthesis are necessary for exponentiation of \Index{complex constant}s or the expression is parsed as ©1.0f+©\R{©(©}©2.0fi \ 3.0f©\R{©)©}©+2.0fi©, requiring \R{©(©}©1.0f+2.0fi©\R{©)©}© \ ©\R{©(©}©3.0f+2.0fi©\R{©)©}.
    610 
     594Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
    611595The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
    612596\begin{cfa}
    613 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
    614 T ?@\@?( T ep, unsigned int y );
    615 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
    616 T ?@\@?( T ep, unsigned long int y );
     597forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
     598OT ?®\®?( OT ep, unsigned int y );
     599forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } )
     600OT ?®\®?( OT ep, unsigned long int y );
    617601\end{cfa}
    618602The user type ©T© must define multiplication, one (©1©), and ©*©.
    … …  
    625609
    626610%\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
    627 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
    628 
    629 The ©if©/©while© expression allows declarations, similar to ©for© declaration expression.\footnote{
    630 Declarations in the ©do©-©while© condition are not useful because they appear after the loop body.}
    631 \begin{cfa}
    632 if ( @int x = f()@ ) ... $\C{// x != 0}$
    633 if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
    634 if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
    635 if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$
    636 
    637 while ( @int x = f()@ ) ... $\C{// x != 0}$
    638 while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
    639 while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
    640 while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$
    641 \end{cfa}
    642 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.
    643 The scope of the declaration(s) is local to the ©if© statement but exist within both the \emph{then} and \emph{else} clauses.
    644 \CC only provides a single declaration always compared ©!=© to 0.
     611\subsection{\texorpdfstring{\LstKeywordStyle{if}/\LstKeywordStyle{while} Statement}{if/while Statement}}
     612
     613The ©if©/©while© expression allows declarations, similar to ©for© declaration expression.
     614(Does not make sense for ©do©-©while©.)
     615\begin{cfa}
     616if ( ®int x = f()® ) ... §\C{// x != 0}§
     617if ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§
     618if ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
     619if ( ®struct S { int i; } x = { f() }; x.i < 4® ) §\C{// relational expression}§
     620
     621while ( ®int x = f()® ) ... §\C{// x != 0}§
     622while ( ®int x = f(), y = g()® ) ... §\C{// x != 0 \&\& y != 0}§
     623while ( ®int x = f(), y = g(); x < y® ) ... §\C{// relational expression}§
     624while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... §\C{// relational expression}§
     625\end{cfa}
     626Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.\footnote{\CC only provides a single declaration always compared not equal to 0.}
     627The scope of the declaration(s) is local to the @if@ statement but exist within both the ``then'' and ``else'' clauses.
    645628
    646629
    647630%\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
    648631\subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
    649 \label{s:caseClause}
    650632
    651633C restricts the ©case© clause of a ©switch© statement to a single value.
    … …  
    658640\begin{cfa}
    659641switch ( i ) {
    660   case @1, 3, 5@:
     642  case ®1, 3, 5®:
    661643        ...
    662   case @2, 4, 6@:
     644  case ®2, 4, 6®:
    663645        ...
    664646}
    … …  
    688670\begin{cfa}
    689671switch ( i ) {
    690   case @1~5:@ $\C{// 1, 2, 3, 4, 5}$
     672  case ®1~5:® §\C{// 1, 2, 3, 4, 5}§
    691673        ...
    692   case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$
     674  case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§
    693675        ...
    694676}
    … …  
    696678Lists of subranges are also allowed.
    697679\begin{cfa}
    698 case @1~5, 12~21, 35~42@:
     680case ®1~5, 12~21, 35~42®:
    699681\end{cfa}
    700682
    … …  
    740722if ( argc == 3 ) {
    741723        // open output file
    742         @// open input file
    743 @} else if ( argc == 2 ) {
    744         @// open input file (duplicate)
    745 
    746 @} else {
     724        ®// open input file
     725®} else if ( argc == 2 ) {
     726        ®// open input file (duplicate)
     727
     728®} else {
    747729        // usage message
    748730}
    … …  
    751733\end{cquote}
    752734In this example, case 2 is always done if case 3 is done.
    753 This control flow is difficult to simulate with ©if© statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
     735This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
    754736C also uses fall-through to handle multiple case-values resulting in the same action:
    755737\begin{cfa}
    756738switch ( i ) {
    757   @case 1: case 3: case 5:@     // odd values
     739  ®case 1: case 3: case 5:®     // odd values
    758740        // odd action
    759741        break;
    760   @case 2: case 4: case 6:@     // even values
     742  ®case 2: case 4: case 6:®     // even values
    761743        // even action
    762744        break;
    763745}
    764746\end{cfa}
    765 This situation better handled without fall-through by allowing a list of case values \see{\VRef{s:caseClause}}.
    766 While fall-through itself is not a problem, the problem occurs when fall-through is the default, as this semantics is unintuitive to many programmers and is different from most programming languages with a ©switch© statement.
     747However, this situation is handled in other languages without fall-through by allowing a list of case values.
     748While 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.
    767749Hence, 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.
    768750
    … …  
    774756        if ( j < k ) {
    775757                ...
    776           @case 1:@             // transfer into "if" statement
     758          ®case 1:®             // transfer into "if" statement
    777759                ...
    778760        } // if
    … …  
    780762        while ( j < 5 ) {
    781763                ...
    782           @case 3:@             // transfer into "while" statement
     764          ®case 3:®             // transfer into "while" statement
    783765                ...
    784766        } // while
    785767} // switch
    786768\end{cfa}
    787 This usage branches into control structures, which is known to cause both comprehension and technical difficulties.
    788 The comprehension problem results from the inability to determine how control reaches a particular point due to the number of branches leading to it.
     769The problem with this usage is branching into control structures, which is known to cause both comprehension and technical difficulties.
     770The comprehension problem occurs from the inability to determine how control reaches a particular point due to the number of branches leading to it.
    789771The technical problem results from the inability to ensure declaration and initialization of variables when blocks are not entered at the beginning.
    790 There are few arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
     772There are no positive arguments for this kind of control flow, and therefore, there is a strong impetus to eliminate it.
    791773Nevertheless, C does have an idiom where this capability is used, known as ``\Index*{Duff's device}''~\cite{Duff83}:
    792774\begin{cfa}
    … …  
    812794\item
    813795It is possible to place the ©default© clause anywhere in the list of labelled clauses for a ©switch© statement, rather than only at the end.
    814 Most programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.
     796Virtually all programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.
    815797The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected;
    816798hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics.
    … …  
    821803\begin{cfa}
    822804switch ( x ) {
    823         @int y = 1;@ $\C{// unreachable initialization}$
    824         @x = 7;@ $\C{// unreachable code without label/branch}$
     805        ®int y = 1;® §\C{// unreachable initialization}§
     806        ®x = 7;® §\C{// unreachable code without label/branch}§
    825807  case 0: ...
    826808        ...
    827         @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$
     809        ®int z = 0;® §\C{// unreachable initialization, cannot appear after case}§
    828810        z = 2;
    829811  case 1:
    830         @x = z;@ $\C{// without fall through, z is uninitialized}$
     812        ®x = z;® §\C{// without fall through, z is uninitialized}§
    831813}
    832814\end{cfa}
    833815While the declaration of the local variable ©y© is useful with a scope across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
    834 Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, where both are problematic.
    835 As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall-through to case 3, ©z© is uninitialized.
    836 The key observation is that the ©switch© statement branches into a control structure, \ie there are multiple entry points into its statement body.
     816Furthermore, any statements before the first ©case© clause can only be executed if labelled and transferred to using a ©goto©, either from outside or inside of the ©switch©, both of which are problematic.
     817As well, the declaration of ©z© cannot occur after the ©case© because a label can only be attached to a statement, and without a fall through to case 3, ©z© is uninitialized.
     818The key observation is that the ©switch© statement branches into control structure, \ie there are multiple entry points into its statement body.
    837819\end{enumerate}
    838820
    … …  
    860842Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
    861843\begin{cfa}
    862 @choose@ ( i ) {
     844®choose® ( i ) {
    863845  case 1:  case 2:  case 3:
    864846        ...
    865         @// implicit end of switch (break)
    866   @case 5:
     847        ®// implicit end of switch (break)
     848  ®case 5:
    867849        ...
    868         @fallthru@; $\C{// explicit fall through}$
     850        ®fallthru®; §\C{// explicit fall through}§
    869851  case 7:
    870852        ...
    871         @break@ $\C{// explicit end of switch (redundant)}$
     853        ®break® §\C{// explicit end of switch (redundant)}§
    872854  default:
    873855        j = 3;
    874856}
    875857\end{cfa}
    876 Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses.
     858Like the ©switch© statement, the ©choose© statement retains the fall-through semantics for a list of ©case© clauses;
    877859An implicit ©break© is applied only at the end of the \emph{statements} following a ©case© clause.
    878860An 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.
    … …  
    890872\begin{cfa}
    891873switch ( x ) {
    892         @int i = 0;@ $\C{// allowed only at start}$
     874        ®int i = 0;® §\C{// allowed only at start}§
    893875  case 0:
    894876        ...
    895         @int j = 0;@ $\C{// disallowed}$
     877        ®int j = 0;® §\C{// disallowed}§
    896878  case 1:
    897879        {
    898                 @int k = 0;@ $\C{// allowed at different nesting levels}$
     880                ®int k = 0;® §\C{// allowed at different nesting levels}§
    899881                ...
    900           @case 2:@ $\C{// disallow case in nested statements}$
     882          ®case 2:® §\C{// disallow case in nested statements}§
    901883        }
    902884  ...
    … …  
    915897  case 3:
    916898        if ( ... ) {
    917                 ... @fallthru;@ // goto case 4
     899                ... ®fallthru;® // goto case 4
    918900        } else {
    919901                ...
    … …  
    930912choose ( ... ) {
    931913  case 3:
    932         ... @fallthrough common;@
     914        ... ®fallthrough common;®
    933915  case 4:
    934         ... @fallthrough common;@
    935 
    936   @common:@ // below fallthrough
     916        ... ®fallthrough common;®
     917
     918  ®common:® // below fallthrough
    937919                          // at case-clause level
    938920        ...     // common code for cases 3/4
    … …  
    950932                for ( ... ) {
    951933                        // multi-level transfer
    952                         ... @fallthru common;@
     934                        ... ®fallthru common;®
    953935                }
    954936                ...
    955937        }
    956938        ...
    957   @common:@ // below fallthrough
     939  ®common:® // below fallthrough
    958940                          // at case-clause level
    959941\end{cfa}
    … …  
    966948
    967949\begin{figure}
    968 \begin{tabular}{@{}l@{\hspace{25pt}}|l@{}}
    969 \multicolumn{1}{@{}c@{\hspace{25pt}}|}{loop control} & \multicolumn{1}{c@{}}{output} \\
     950\begin{tabular}{@{}l|l@{}}
     951\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
    970952\hline
    971 \begin{cfa}
    972 while @($\,$)@ { sout | "empty"; break; }
    973 do { sout | "empty"; break; } while @($\,$)@;
    974 for @($\,$)@ { sout | "empty"; break; }
    975 for ( @0@ ) { sout | "A"; } sout | "zero";
    976 for ( @1@ ) { sout | "A"; }
    977 for ( @10@ ) { sout | "A"; }
    978 for ( @= 10@ ) { sout | "A"; }
    979 for ( @1 ~= 10 ~ 2@ ) { sout | "B"; }
    980 for ( @10 -~= 1 ~ 2@ ) { sout | "C"; }
    981 for ( @0.5 ~ 5.5@ ) { sout | "D"; }
    982 for ( @5.5 -~ 0.5@ ) { sout | "E"; }
    983 for ( @i; 10@ ) { sout | i; }
    984 for ( @i; = 10@ ) { sout | i; }
    985 for ( @i; 1 ~= 10 ~ 2@ ) { sout | i; }
    986 for ( @i; 10 -~= 1 ~ 2@ ) { sout | i; }
    987 for ( @i; 0.5 ~ 5.5@ ) { sout | i; }
    988 for ( @i; 5.5 -~ 0.5@ ) { sout | i; }
    989 for ( @ui; 2u ~= 10u ~ 2u@ ) { sout | ui; }
    990 for ( @ui; 10u -~= 2u ~ 2u@ ) { sout | ui; }
     953\begin{cfa}[xleftmargin=0pt]
     954while ®()® { sout | "empty"; break; }
     955do { sout | "empty"; break; } while ®()®;
     956for ®()® { sout | "empty"; break; }
     957for ( ®0® ) { sout | "A"; } sout | "zero";
     958for ( ®1® ) { sout | "A"; }
     959for ( ®10® ) { sout | "A"; }
     960for ( ®= 10® ) { sout | "A"; }
     961for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
     962for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
     963for ( ®0.5 ~ 5.5® ) { sout | "D"; }
     964for ( ®5.5 -~ 0.5® ) { sout | "E"; }
     965for ( ®i; 10® ) { sout | i; }
     966for ( ®i; = 10® ) { sout | i; }
     967for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
     968for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
     969for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
     970for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
     971for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
     972for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
    991973enum { N = 10 };
    992 for ( @N@ ) { sout | "N"; }
    993 for ( @i; N@ ) { sout | i; }
    994 for ( @i; N -~ 0@ ) { sout | i; }
     974for ( ®N® ) { sout | "N"; }
     975for ( ®i; N® ) { sout | i; }
     976for ( ®i; N -~ 0® ) { sout | i; }
    995977const int start = 3, comp = 10, inc = 2;
    996 for ( @i; start ~ comp ~ inc + 1@ ) { sout | i; }
    997 for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout | i; }
    998 for ( i; 10 -~ $\R{@}$ ) { if ( i < 0 ) break; sout | i; }
    999 for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout | i; }
    1000 for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
    1001 for ( i; 10 -~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout | i; }
    1002 for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
    1003 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
    1004 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
    1005 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
    1006 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
    1007 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
    1008 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
    1009 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
    1010 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
    1011 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
    1012 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
    1013 for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j | k; }
     978for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
     979for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
     980for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
     981for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
     982for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
     983for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
     984for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
     985for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
     986for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
     987for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
     988for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
     989for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
     990for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
     991for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
     992for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
     993for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
     994for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
     995for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
    1014996\end{cfa}
    1015997&
    … …  
    10741056\subsection{Loop Control}
    10751057
    1076 Looping a fixed number of times, possibly with a loop index, occurs frequently.
    1077 \CFA condenses simply looping to facilitate coding speed and safety.
    1078 The ©for©/©while©/©do-while© loop-control is augmented as follows \see{examples in \VRef[Figure]{f:LoopControlExamples}}:
    1079 \begin{itemize}[itemsep=0pt]
     1058The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
     1059\begin{itemize}
     1060\item
     1061The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
     1062\item
     1063An empty conditional implies comparison value of ©1© (true).
     1064\item
     1065A comparison N is implicit up-to exclusive range [0,N©®)®©.
     1066\item
     1067A comparison ©=© N is implicit up-to inclusive range [0,N©®]®©.
     1068\item
     1069The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©.
     1070\item
     1071The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©.
     1072\item
     1073The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M©®)®©.
     1074\item
     1075The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M©®]®©.
    10801076\item
    10811077©0© is the implicit start value;
    … …  
    10871083The down-to range uses operator ©-=© for decrement.
    10881084\item
    1089 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
    1090 \begin{cfa}
    1091 for ( i; @5@ )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
    1092 for ( i; @1.5@~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
    1093 \end{cfa}
    1094 \item
    1095 An empty conditional implies comparison value of ©1© (true).
    1096 \begin{cfa}
    1097 while ( $\R{/*empty*/}$ )               $\C{// while ( true )}$
    1098 for ( $\R{/*empty*/}$ )                 $\C{// for ( ; true; )}$
    1099 do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$
    1100 \end{cfa}
    1101 \item
    1102 A comparison N is implicit up-to exclusive range [0,N\R{)}.
    1103 \begin{cfa}
    1104 for ( @5@ )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
    1105 \end{cfa}
    1106 \item
    1107 A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.
    1108 \begin{cfa}
    1109 for ( @=@5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
    1110 \end{cfa}
    1111 \item
    1112 The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}.
    1113 \begin{cfa}
    1114 for ( 1@~@5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
    1115 \end{cfa}
    1116 \item
    1117 The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}.
    1118 \begin{cfa}
    1119 for ( 1@~=@5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
    1120 \end{cfa}
    1121 \item
    1122 The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M\R{)}.
    1123 \begin{cfa}
    1124 for ( 1@-~@5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
    1125 \end{cfa}
    1126 \item
    1127 The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M\R{]}.
    1128 \begin{cfa}
    1129 for ( 1@-~=@5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
    1130 \end{cfa}
    1131 \item
    11321085©@© means put nothing in this field.
    1133 \begin{cfa}
    1134 for ( 1~$\R{@}$~2 )                             $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
    1135 \end{cfa}
    11361086\item
    11371087©:© means start another index.
    1138 \begin{cfa}
    1139 for ( i; 5 @:@ j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
    1140 \end{cfa}
    11411088\end{itemize}
    11421089
    … …  
    11451092\subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
    11461093
    1147 C ©continue© and ©break© statements, for altering control flow, are restricted to one level of nesting for a particular control structure.
    1148 This restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
     1094While C provides ©continue© and ©break© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
     1095Unfortunately, this restriction forces programmers to use \Indexc{goto} to achieve the equivalent control-flow for more than one level of nesting.
    11491096To prevent having to switch to the ©goto©, \CFA extends the \Indexc{continue}\index{continue@©continue©!labelled}\index{labelled!continue@©continue©} and \Indexc{break}\index{break@©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.
    11501097For both ©continue© and ©break©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
    11511098for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
    1152 \VRef[Figure]{f:MultiLevelExit} shows a comparison between labelled ©continue© and ©break© and the corresponding C equivalent using ©goto© and labels.
     1099\VRef[Figure]{f:MultiLevelExit} shows ©continue© and ©break© indicating the specific control structure, and the corresponding C program using only ©goto© and labels.
    11531100The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
    11541101
    … …  
    11571104\begin{lrbox}{\myboxA}
    11581105\begin{cfa}[tabsize=3]
    1159 @Compound:@ {
    1160         @Try:@ try {
    1161                 @For:@ for ( ... ) {
    1162                         @While:@ while ( ... ) {
    1163                                 @Do:@ do {
    1164                                         @If:@ if ( ... ) {
    1165                                                 @Switch:@ switch ( ... ) {
     1106®Compound:® {
     1107        ®Try:® try {
     1108                ®For:® for ( ... ) {
     1109                        ®While:® while ( ... ) {
     1110                                ®Do:® do {
     1111                                        ®If:® if ( ... ) {
     1112                                                ®Switch:® switch ( ... ) {
    11661113                                                        case 3:
    1167                                                                 @break Compound@;
    1168                                                                 @break Try@;
    1169                                                                 @break For@;      /* or */  @continue For@;
    1170                                                                 @break While@;  /* or */  @continue While@;
    1171                                                                 @break Do@;      /* or */  @continue Do@;
    1172                                                                 @break If@;
    1173                                                                 @break Switch@;
     1114                                                                ®break Compound®;
     1115                                                                ®break Try®;
     1116                                                                ®break For®;      /* or */  ®continue For®;
     1117                                                                ®break While®;  /* or */  ®continue While®;
     1118                                                                ®break Do®;      /* or */  ®continue Do®;
     1119                                                                ®break If®;
     1120                                                                ®break Switch®;
    11741121                                                        } // switch
    11751122                                                } else {
    1176                                                         ... @break If@; ...     // terminate if
     1123                                                        ... ®break If®; ...     // terminate if
    11771124                                                } // if
    11781125                                } while ( ... ); // do
    11791126                        } // while
    11801127                } // for
    1181         } @finally@ { // always executed
     1128        } ®finally® { // always executed
    11821129        } // try
    11831130} // compound
    … …  
    11891136{
    11901137
    1191                 @ForC:@ for ( ... ) {
    1192                         @WhileC:@ while ( ... ) {
    1193                                 @DoC:@ do {
     1138                ®ForC:® for ( ... ) {
     1139                        ®WhileC:® while ( ... ) {
     1140                                ®DoC:® do {
    11941141                                        if ( ... ) {
    11951142                                                switch ( ... ) {
    11961143                                                        case 3:
    1197                                                                 @goto Compound@;
    1198                                                                 @goto Try@;
    1199                                                                 @goto ForB@;      /* or */  @goto ForC@;
    1200                                                                 @goto WhileB@;  /* or */  @goto WhileC@;
    1201                                                                 @goto DoB@;      /* or */  @goto DoC@;
    1202                                                                 @goto If@;
    1203                                                                 @goto Switch@;
    1204                                                         } @Switch:@ ;
     1144                                                                ®goto Compound®;
     1145                                                                ®goto Try®;
     1146                                                                ®goto ForB®;      /* or */  ®goto ForC®;
     1147                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
     1148                                                                ®goto DoB®;      /* or */  ®goto DoC®;
     1149                                                                ®goto If®;
     1150                                                                ®goto Switch®;
     1151                                                        } ®Switch:® ;
    12051152                                                } else {
    1206                                                         ... @goto If@; ...      // terminate if
    1207                                                 } @If:@;
    1208                                 } while ( ... ); @DoB:@ ;
    1209                         } @WhileB:@ ;
    1210                 } @ForB:@ ;
    1211 
    1212 
    1213 } @Compound:@ ;
     1153                                                        ... ®goto If®; ...      // terminate if
     1154                                                } ®If:®;
     1155                                } while ( ... ); ®DoB:® ;
     1156                        } ®WhileB:® ;
     1157                } ®ForB:® ;
     1158
     1159
     1160} ®Compound:® ;
    12141161\end{cfa}
    12151162\end{lrbox}
    12161163
    12171164\subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA}
    1218 \hspace{3pt}
     1165\hspace{2pt}
    12191166\vrule
    1220 \hspace{3pt}
     1167\hspace{2pt}
    12211168\subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB}
    12221169\caption{Multi-level Exit}
    … …  
    12331180This restriction prevents missing declarations and/or initializations at the start of a control structure resulting in undefined behaviour.
    12341181\end{itemize}
    1235 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 via a label.
     1182The 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.
    12361183Furthermore, 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.
    12371184With ©goto©, the label is at the end of the control structure, which fails to convey this important clue early enough to the reader.
    … …  
    12401187
    12411188
    1242 %\subsection{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
    1243 \subsection{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
     1189%\section{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
     1190\section{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
    12441191\label{s:WithStatement}
    12451192
    1246 Grouping heterogeneous data into an \newterm{aggregate} (structure/union) is a common programming practice, and aggregates may be nested:
    1247 \begin{cfa}
    1248 struct Person {                                                         $\C{// aggregate}$
    1249         struct Name { char first[20], last[20]; } name $\C{// nesting}$
    1250         struct Address { ... } address                  $\C{// nesting}$
    1251         int sex;
     1193Grouping heterogeneous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
     1194\begin{cfa}
     1195struct S { §\C{// aggregate}§
     1196        char c; §\C{// fields}§
     1197        int i;
     1198        double d;
    12521199};
    1253 \end{cfa}
    1254 Functions manipulating aggregates must repeat the aggregate name to access its containing fields.
    1255 \begin{cfa}
    1256 Person p
    1257 @p.@name; @p.@address; @p.@sex; $\C{// access containing fields}$
    1258 \end{cfa}
    1259 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
    1260 \begin{cfa}
    1261 struct Ticket { ... } t;
    1262 @p.name@.first; @p.address@.street;             $\C{// access nested fields}$
    1263 @t.@departure; @t.@cost;                                $\C{// access multiple aggregate}$
    1264 \end{cfa}
    1265 Repeated aggregate qualification is tedious and makes code difficult to read.
    1266 Therefore, reducing aggregate qualification is a useful language design goal.
    1267 
    1268 C allows unnamed nested aggregates that open their scope into the containing aggregate.
    1269 This feature is used to group fields for attributes and/or with ©union© aggregates.
    1270 \begin{cfa}
    1271 struct S {
    1272         struct { int g,  h; } __attribute__(( aligned(64) ));
    1273         int tag;
    1274         union {
    1275                 struct { char c1,  c2; } __attribute__(( aligned(128) ));
    1276                 struct { int i1,  i2; };
    1277                 struct { double d1,  d2; };
    1278         };
    1279 };
    1280 s.g; s.h; s.tag; s.c1; s.c2; s.i1; s.i2; s.d1; s.d2;
    1281 \end{cfa}
    1282 
    1283 Object-oriented languages reduce qualification for class variables within member functions, \eg \CC:
     1200S s, as[10];
     1201\end{cfa}
     1202However, functions manipulating aggregates must repeat the aggregate name to access its containing fields:
     1203\begin{cfa}
     1204void f( S s ) {
     1205        ®s.®c; ®s.®i; ®s.®d; §\C{// access containing fields}§
     1206}
     1207\end{cfa}
     1208which extends to multiple levels of qualification for nested aggregates.
     1209A similar situation occurs in object-oriented programming, \eg \CC:
    12841210\begin{C++}
    12851211struct S {
    1286         char @c@;   int @i@;   double @d@;
    1287         void f( /* S * this */ ) {                              $\C{// implicit ``this'' parameter}$
    1288                 @c@;   @i@;   @d@;                                      $\C{// this->c; this->i; this->d;}$
     1212        char c; §\C{// fields}§
     1213        int i;
     1214        double d;
     1215        void f() { §\C{// implicit ``this'' aggregate}§
     1216                ®this->®c; ®this->®i; ®this->®d; §\C{// access containing fields}§
    12891217        }
    12901218}
    12911219\end{C++}
    1292 In general, qualification is elided for the variables and functions in the lexical scopes visible from a member function.
    1293 However, qualification is necessary for name shadowing and explicit aggregate parameters.
    1294 \begin{cfa}
    1295 struct T {
    1296         char @m@;   int @i@;   double @n@;              $\C{// derived class variables}$
    1297 };
    1298 struct S : public T {
    1299         char @c@;   int @i@;   double @d@;              $\C{// class variables}$
    1300         void g( double @d@, T & t ) {
    1301                 d;   @t@.m;   @t@.i;   @t@.n;           $\C{// function parameter}$
    1302                 c;   i;   @this->@d;   @S::@d;          $\C{// class S variables}$
    1303                 m;   @T::@i;   n;                                       $\C{// class T variables}$
    1304         }
    1305 };
    1306 \end{cfa}
    1307 Note the three different forms of qualification syntax in \CC, ©.©, ©->©, ©::©, which is confusing.
    1308 
    1309 Since \CFA in not object-oriented, it has no implicit parameter with its implicit qualification.
    1310 Instead \CFA introduces a general mechanism using the ©with© statement \see{Pascal~\cite[\S~4.F]{Pascal}} to explicitly elide aggregate qualification by opening a scope containing the field identifiers.
    1311 Hence, the qualified fields become variables with the side-effect that it is simpler to write, easier to read, and optimize field references in a block.
    1312 \begin{cfa}
    1313 void f( S & this ) @with ( this )@ {            $\C{// with statement}$
    1314         @c@;   @i@;   @d@;                                              $\C{// this.c, this.i, this.d}$
     1220Object-oriented nesting of member functions in a \lstinline[language=C++]@class/struct@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
     1221However, for other aggregate parameters, qualification is necessary:
     1222\begin{cfa}
     1223struct T { double m, n; };
     1224int S::f( T & t ) { §\C{// multiple aggregate parameters}§
     1225        c; i; d; §\C{\color{red}// this--{\textgreater}.c, this--{\textgreater}.i, this--{\textgreater}.d}§
     1226        ®t.®m; ®t.®n; §\C{// must qualify}§
     1227}
     1228\end{cfa}
     1229
     1230To simplify the programmer experience, \CFA provides a ©with© statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
     1231Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
     1232\begin{cfa}
     1233void f( S & this ) ®with ( this )® { §\C{// with statement}§
     1234        c; i; d; §\C{\color{red}// this.c, this.i, this.d}§
    13151235}
    13161236\end{cfa}
    13171237with the generality of opening multiple aggregate-parameters:
    13181238\begin{cfa}
    1319 void g( S & s, T & t ) @with ( s, t )@ {        $\C{// multiple aggregate parameters}$
    1320         c;   @s.@i;   d;                                                $\C{// s.c, s.i, s.d}$
    1321         m;   @t.@i;   n;                                                $\C{// t.m, t.i, t.n}$
    1322 }
    1323 \end{cfa}
    1324 where qualification is only necessary to disambiguate the shadowed variable ©i©.
    1325 
    1326 In detail, the ©with© statement may appear as the body of a function or nested within a function body.
    1327 The ©with© clause takes a list of expressions, where each expression provides an aggregate type and object.
     1239void f( S & s, T & t ) ®with ( s, t )® { §\C{// multiple aggregate parameters}§
     1240        c; i; d; §\C{\color{red}// s.c, s.i, s.d}§
     1241        m; n; §\C{\color{red}// t.m, t.n}§
     1242}
     1243\end{cfa}
     1244
     1245In detail, the ©with© statement has the form:
     1246\begin{cfa}
     1247§\emph{with-statement}§:
     1248        'with' '(' §\emph{expression-list}§ ')' §\emph{compound-statement}§
     1249\end{cfa}
     1250and may appear as the body of a function or nested within a function body.
     1251Each expression in the expression-list provides a type and object.
     1252The type must be an aggregate type.
    13281253(Enumerations are already opened.)
    1329 To open a pointer type, the pointer must be dereferenced to obtain a reference to the aggregate type.
    1330 \begin{cfa}
    1331 S * sp;
    1332 with ( *sp ) { ... }
    1333 \end{cfa}
    1334 The expression object is the implicit qualifier for the open structure-fields.
    1335 \CFA's ability to overload variables \see{\VRef{s:VariableOverload}} and use the left-side of assignment in type resolution means most fields with the same name but different types are automatically disambiguated, eliminating qualification.
     1254The object is the implicit qualifier for the open structure-fields.
     1255
    13361256All expressions in the expression list are open in parallel within the compound statement.
    13371257This semantic is different from Pascal, which nests the openings from left to right.
    13381258The difference between parallel and nesting occurs for fields with the same name and type:
    13391259\begin{cfa}
    1340 struct Q { int @i@; int k; int @m@; } q, w;
    1341 struct R { int @i@; int j; double @m@; } r, w;
    1342 with ( r, q ) {
    1343         j + k;                                                                  $\C{// unambiguous, r.j + q.k}$
    1344         m = 5.0;                                                                $\C{// unambiguous, q.m = 5.0}$
    1345         m = 1;                                                                  $\C{// unambiguous, r.m = 1}$
    1346         int a = m;                                                              $\C{// unambiguous, a = r.i }$
    1347         double b = m;                                                   $\C{// unambiguous, b = q.m}$
    1348         int c = r.i + q.i;                                              $\C{// disambiguate with qualification}$
    1349         (double)m;                                                              $\C{// disambiguate with cast}$
    1350 }
    1351 \end{cfa}
    1352 For parallel semantics, both ©r.i© and ©q.i© are visible, so ©i© is ambiguous without qualification;
    1353 for nested semantics, ©q.i© hides ©r.i©, so ©i© implies ©q.i©.
    1354 Pascal nested-semantics is possible by nesting ©with© statements.
    1355 \begin{cfa}
    1356 with ( r ) {
    1357         i;                                                                              $\C{// unambiguous, r.i}$
    1358         with ( q ) {
    1359                 i;                                                                      $\C{// unambiguous, q.i}$
    1360         }
    1361 }
    1362 \end{cfa}
    1363 A cast or qualification can be used to disambiguate variables within a ©with© \emph{statement}.
    1364 A cast can be used to disambiguate among overload variables in a ©with© \emph{expression}:
    1365 \begin{cfa}
    1366 with ( w ) { ... }                                                      $\C{// ambiguous, same name and no context}$
    1367 with ( (Q)w ) { ... }                                           $\C{// unambiguous, cast}$
    1368 \end{cfa}
    1369 Because there is no left-side in the ©with© expression to implicitly disambiguate between the ©w© variables, it is necessary to explicitly disambiguate by casting ©w© to type ©Q© or ©R©.
    1370 
    1371 Finally, there is an interesting problem between parameters and the function-body ©with©, \eg:
    1372 \begin{cfa}
    1373 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$
    1374         @s.i = i;@  j = 3;  m = 5.5; $\C{// initialize fields}$
     1260struct S { int ®i®; int j; double m; } s, w;
     1261struct T { int ®i®; int k; int m; } t, w;
     1262with ( s, t ) {
     1263        j + k; §\C{// unambiguous, s.j + t.k}§
     1264        m = 5.0; §\C{// unambiguous, t.m = 5.0}§
     1265        m = 1; §\C{// unambiguous, s.m = 1}§
     1266        int a = m; §\C{// unambiguous, a = s.i }§
     1267        double b = m; §\C{// unambiguous, b = t.m}§
     1268        int c = s.i + t.i; §\C{// unambiguous, qualification}§
     1269        (double)m; §\C{// unambiguous, cast}§
     1270}
     1271\end{cfa}
     1272For parallel semantics, both ©s.i© and ©t.i© are visible, so ©i© is ambiguous without qualification;
     1273for nested semantics, ©t.i© hides ©s.i©, so ©i© implies ©t.i©.
     1274\CFA's ability to overload variables means fields with the same name but different types are automatically disambiguated, eliminating most qualification when opening multiple aggregates.
     1275Qualification or a cast is used to disambiguate.
     1276
     1277There is an interesting problem between parameters and the function-body ©with©, \eg:
     1278\begin{cfa}
     1279void ?{}( S & s, int i ) with ( s ) { §\C{// constructor}§
     1280        ®s.i = i;®  j = 3;  m = 5.5; §\C{// initialize fields}§
    13751281}
    13761282\end{cfa}
    … …  
    13851291and implicitly opened \emph{after} a function-body open, to give them higher priority:
    13861292\begin{cfa}
    1387 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { // syntax not allowed, illustration only
    1388         s.i = @i@; j = 3; m = 5.5;
    1389 }
    1390 \end{cfa}
    1391 This implicit semantic matches with programmer expectation.
    1392 
     1293void ?{}( S & s, int ®i® ) with ( s ) ®with( §\emph{\color{red}params}§ )® {
     1294        s.i = ®i®; j = 3; m = 5.5;
     1295}
     1296\end{cfa}
     1297Finally, a cast may be used to disambiguate among overload variables in a ©with© expression:
     1298\begin{cfa}
     1299with ( w ) { ... } §\C{// ambiguous, same name and no context}§
     1300with ( (S)w ) { ... } §\C{// unambiguous, cast}§
     1301\end{cfa}
     1302and ©with© expressions may be complex expressions with type reference (see Section~\ref{s:References}) to aggregate:
     1303% \begin{cfa}
     1304% struct S { int i, j; } sv;
     1305% with ( sv ) { §\C{// implicit reference}§
     1306%       S & sr = sv;
     1307%       with ( sr ) { §\C{// explicit reference}§
     1308%               S * sp = &sv;
     1309%               with ( *sp ) { §\C{// computed reference}§
     1310%                       i = 3; j = 4; §\C{\color{red}// sp--{\textgreater}i, sp--{\textgreater}j}§
     1311%               }
     1312%               i = 2; j = 3; §\C{\color{red}// sr.i, sr.j}§
     1313%       }
     1314%       i = 1; j = 2; §\C{\color{red}// sv.i, sv.j}§
     1315% }
     1316% \end{cfa}
     1317
     1318In \Index{object-oriented} programming, there is an implicit first parameter, often names \textbf{©self©} or \textbf{©this©}, which is elided.
     1319\begin{C++}
     1320class C {
     1321        int i, j;
     1322        int mem() { §\C{\color{red}// implicit "this" parameter}§
     1323                i = 1; §\C{\color{red}// this->i}§
     1324                j = 2; §\C{\color{red}// this->j}§
     1325        }
     1326}
     1327\end{C++}
     1328Since \CFA is non-object-oriented, the equivalent object-oriented program looks like:
     1329\begin{cfa}
     1330struct S { int i, j; };
     1331int mem( S & ®this® ) { §\C{// explicit "this" parameter}§
     1332        ®this.®i = 1; §\C{// "this" is not elided}§
     1333        ®this.®j = 2;
     1334}
     1335\end{cfa}
     1336but it is cumbersome having to write ``©this.©'' many times in a member.
     1337
     1338\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.
     1339\begin{cfa}
     1340int mem( S & this ) ®with( this )® { §\C{// with clause}§
     1341        i = 1; §\C{\color{red}// this.i}§
     1342        j = 2; §\C{\color{red}// this.j}§
     1343}
     1344\end{cfa}
     1345which extends to multiple routine parameters:
     1346\begin{cfa}
     1347struct T { double m, n; };
     1348int mem2( S & this1, T & this2 ) ®with( this1, this2 )® {
     1349        i = 1; j = 2;
     1350        m = 1.0; n = 2.0;
     1351}
     1352\end{cfa}
     1353
     1354The statement form is used within a block:
     1355\begin{cfa}
     1356int foo() {
     1357        struct S1 { ... } s1;
     1358        struct S2 { ... } s2;
     1359        ®with( s1 )® { §\C{// with statement}§
     1360                // access fields of s1 without qualification
     1361                ®with s2® { §\C{// nesting}§
     1362                        // access fields of s1 and s2 without qualification
     1363                }
     1364        }
     1365        ®with s1, s2® {
     1366                // access unambiguous fields of s1 and s2 without qualification
     1367        }
     1368}
     1369\end{cfa}
     1370
     1371When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
     1372For fields with the same name but different type, context/cast can be used to disambiguate.
     1373\begin{cfa}
     1374struct S { int i; int j; double m; } a, c;
     1375struct T { int i; int k; int m } b, c;
     1376with( a, b )
     1377{
     1378}
     1379\end{cfa}
     1380
     1381\begin{comment}
     1382The components in the "with" clause
     1383
     1384  with a, b, c { ... }
     1385
     1386serve 2 purposes: each component provides a type and object. The type must be a
     1387structure type. Enumerations are already opened, and I think a union is opened
     1388to some extent, too. (Or is that just unnamed unions?) The object is the target
     1389that the naked structure-fields apply to. The components are open in "parallel"
     1390at the scope of the "with" clause/statement, so opening "a" does not affect
     1391opening "b", etc. This semantic is different from Pascal, which nests the
     1392openings.
     1393
     1394Having said the above, it seems reasonable to allow a "with" component to be an
     1395expression. The type is the static expression-type and the object is the result
     1396of the expression. Again, the type must be an aggregate. Expressions require
     1397parenthesis around the components.
     1398
     1399  with( a, b, c ) { ... }
     1400
     1401Does this now make sense?
     1402
     1403Having written more CFA code, it is becoming clear to me that I *really* want
     1404the "with" to be implemented because I hate having to type all those object
     1405names for fields. It's a great way to drive people away from the language.
     1406\end{comment}
    13931407
    13941408
    … …  
    14001414Non-local transfer can cause stack unwinding, \ie non-local routine termination, depending on the kind of raise.
    14011415\begin{cfa}
    1402 exception_t E {}; $\C{// exception type}$
     1416exception_t E {}; §\C{// exception type}§
    14031417void f(...) {
    1404         ... throw E{}; ... $\C{// termination}$
    1405         ... throwResume E{}; ... $\C{// resumption}$
     1418        ... throw E{}; ... §\C{// termination}§
     1419        ... throwResume E{}; ... §\C{// resumption}§
    14061420}
    14071421try {
    14081422        f(...);
    1409 } catch( E e ; $boolean-predicate$ ) {          $\C{// termination handler}$
     1423} catch( E e ; §boolean-predicate§ ) {          §\C{// termination handler}§
    14101424        // recover and continue
    1411 } catchResume( E e ; $boolean-predicate$ ) { $\C{// resumption handler}$
     1425} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}§
    14121426        // repair and return
    14131427} finally {
    … …  
    14161430\end{cfa}
    14171431The kind of raise and handler match: ©throw© with ©catch© and ©throwResume© with ©catchResume©.
    1418 Then the exception type must match along with any additional predicate must be true.
     1432Then the exception type must match along with any additonal predicate must be true.
    14191433The ©catch© and ©catchResume© handlers may appear in any oder.
    14201434However, the ©finally© clause must appear at the end of the ©try© statement.
    … …  
    14691483For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
    14701484\begin{cfa}
    1471 int @(*@f@())[@5@]@ {...}; $\C{// definition}$
    1472  ... @(*@f@())[@3@]@ += 1; $\C{// usage}$
     1485int ®(*®f®())[®5®]® {...}; §\C{// definition}§
     1486 ... ®(*®f®())[®3®]® += 1; §\C{// usage}§
    14731487\end{cfa}
    14741488Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
    … …  
    14851499\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    14861500\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    1487 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
    1488 #[5] *# @int@ x1;
    1489 #* [5]# @int@ x2;
    1490 #[* [5] int]# f@( int p )@;
     1501\begin{cfa}
     1502ß[5] *ß ®int® x1;
     1503ß* [5]ß ®int® x2;
     1504ß[* [5] int]ß f®( int p )®;
    14911505\end{cfa}
    14921506&
    1493 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
    1494 @int@ #*# x1 #[5]#;
    1495 @int@ #(*#x2#)[5]#;
    1496 #int (*#f@( int p )@#)[5]#;
     1507\begin{cfa}
     1508®int® ß*ß x1 ß[5]ß;
     1509®int® ß(*ßx2ß)[5]ß;
     1510ßint (*ßf®( int p )®ß)[5]ß;
    14971511\end{cfa}
    14981512\end{tabular}
    … …  
    15061520\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    15071521\begin{cfa}
    1508 @*@ int x, y;
     1522®*® int x, y;
    15091523\end{cfa}
    15101524&
    15111525\begin{cfa}
    1512 int @*@x, @*@y;
     1526int ®*®x, ®*®y;
    15131527\end{cfa}
    15141528\end{tabular}
    … …  
    15191533\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    15201534\begin{cfa}
    1521 @*@ int x;
     1535®*® int x;
    15221536int y;
    15231537\end{cfa}
    15241538&
    15251539\begin{cfa}
    1526 int @*@x, y;
     1540int ®*®x, y;
    15271541
    15281542\end{cfa}
    … …  
    16331647
    16341648\section{Pointer / Reference}
    1635 \label{s:PointerReference}
    16361649
    16371650C provides a \newterm{pointer type};
    … …  
    16601673&
    16611674\begin{cfa}
    1662 int * @const@ x = (int *)100
     1675int * ®const® x = (int *)100
    16631676*x = 3;                 // implicit dereference
    1664 int * @const@ y = (int *)104;
     1677int * ®const® y = (int *)104;
    16651678*y = *x;                        // implicit dereference
    16661679\end{cfa}
    … …  
    17001713\begin{tabular}{@{}l@{\hspace{2em}}l@{}}
    17011714\begin{cfa}
    1702 int x, y, @*@ p1, @*@ p2, @**@ p3;
    1703 p1 = @&@x;     // p1 points to x
     1715int x, y, ®*® p1, ®*® p2, ®**® p3;
     1716p1 = ®&®x;     // p1 points to x
    17041717p2 = p1;     // p2 points to x
    1705 p1 = @&@y;     // p1 points to y
     1718p1 = ®&®y;     // p1 points to y
    17061719p3 = &p2;  // p3 points to p2
    17071720\end{cfa}
    … …  
    17151728For example, \Index*{Algol68}~\cite{Algol68} infers pointer dereferencing to select the best meaning for each pointer usage
    17161729\begin{cfa}
    1717 p2 = p1 + x; $\C{// compiler infers *p2 = *p1 + x;}$
     1730p2 = p1 + x; §\C{// compiler infers *p2 = *p1 + x;}§
    17181731\end{cfa}
    17191732Algol68 infers the following dereferencing ©*p2 = *p1 + x©, because adding the arbitrary integer value in ©x© to the address of ©p1© and storing the resulting address into ©p2© is an unlikely operation.
    … …  
    17231736In C, objects of pointer type always manipulate the pointer object's address:
    17241737\begin{cfa}
    1725 p1 = p2; $\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}$
    1726 p2 = p1 + x; $\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}$
     1738p1 = p2; §\C{// p1 = p2\ \ rather than\ \ *p1 = *p2}§
     1739p2 = p1 + x; §\C{// p2 = p1 + x\ \ rather than\ \ *p2 = *p1 + x}§
    17271740\end{cfa}
    17281741even though the assignment to ©p2© is likely incorrect, and the programmer probably meant:
    17291742\begin{cfa}
    1730 p1 = p2; $\C{// pointer address assignment}$
    1731 @*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$
     1743p1 = p2; §\C{// pointer address assignment}§
     1744®*®p2 = ®*®p1 + x; §\C{// pointed-to value assignment / operation}§
    17321745\end{cfa}
    17331746The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
    … …  
    17451758To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s).
    17461759\begin{cfa}
    1747 int x, y, @&@ r1, @&@ r2, @&&@ r3;
    1748 @&@r1 = &x; $\C{// r1 points to x}$
    1749 @&@r2 = &r1; $\C{// r2 points to x}$
    1750 @&@r1 = &y; $\C{// r1 points to y}$
    1751 @&&@r3 = @&@&r2; $\C{// r3 points to r2}$
    1752 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
     1760int x, y, ®&® r1, ®&® r2, ®&&® r3;
     1761®&®r1 = &x; §\C{// r1 points to x}§
     1762®&®r2 = &r1; §\C{// r2 points to x}§
     1763®&®r1 = &y; §\C{// r1 points to y}§
     1764®&&®r3 = ®&®&r2; §\C{// r3 points to r2}§
     1765r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); §\C{// implicit dereferencing}§
    17531766\end{cfa}
    17541767Except for auto-dereferencing by the compiler, this reference example is the same as the previous pointer example.
    … …  
    17561769One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in a declaration, so the previous example becomes:
    17571770\begin{cfa}
    1758 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);
     1771®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
    17591772\end{cfa}
    17601773When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
    … …  
    17651778For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
    17661779\begin{cfa}
    1767 (&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
     1780(&®*®)r1 = &x; §\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}§
    17681781\end{cfa}
    17691782Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
    17701783\begin{cfa}
    1771 (&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
     1784(&(&®*®)®*®)r3 = &(&®*®)r2; §\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}§
    17721785\end{cfa}
    17731786Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
    … …  
    17771790int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
    17781791                 &r1 = x,    &&r2 = r1,   &&&r3 = r2;
    1779 ***p3 = 3; $\C{// change x}$
    1780 r3 = 3; $\C{// change x, ***r3}$
    1781 **p3 = ...; $\C{// change p1}$
    1782 &r3 = ...; $\C{// change r1, (\&*)**r3, 1 cancellation}$
    1783 *p3 = ...; $\C{// change p2}$
    1784 &&r3 = ...; $\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}$
    1785 &&&r3 = p3; $\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}$
     1792***p3 = 3; §\C{// change x}§
     1793r3 = 3; §\C{// change x, ***r3}§
     1794**p3 = ...; §\C{// change p1}§
     1795&r3 = ...; §\C{// change r1, (\&*)**r3, 1 cancellation}§
     1796*p3 = ...; §\C{// change p2}§
     1797&&r3 = ...; §\C{// change r2, (\&(\&*)*)*r3, 2 cancellations}§
     1798&&&r3 = p3; §\C{// change r3 to p3, (\&(\&(\&*)*)*)r3, 3 cancellations}§
    17861799\end{cfa}
    17871800Furthermore, both types are equally performant, as the same amount of dereferencing occurs for both types.
    … …  
    17901803As for a pointer type, a reference type may have qualifiers:
    17911804\begin{cfa}
    1792 const int cx = 5; $\C{// cannot change cx;}$
    1793 const int & cr = cx; $\C{// cannot change what cr points to}$
    1794 @&@cr = &cx; $\C{// can change cr}$
    1795 cr = 7; $\C{// error, cannot change cx}$
    1796 int & const rc = x; $\C{// must be initialized}$
    1797 @&@rc = &x; $\C{// error, cannot change rc}$
    1798 const int & const crc = cx; $\C{// must be initialized}$
    1799 crc = 7; $\C{// error, cannot change cx}$
    1800 @&@crc = &cx; $\C{// error, cannot change crc}$
     1805const int cx = 5; §\C{// cannot change cx;}§
     1806const int & cr = cx; §\C{// cannot change what cr points to}§
     1807®&®cr = &cx; §\C{// can change cr}§
     1808cr = 7; §\C{// error, cannot change cx}§
     1809int & const rc = x; §\C{// must be initialized}§
     1810®&®rc = &x; §\C{// error, cannot change rc}§
     1811const int & const crc = cx; §\C{// must be initialized}§
     1812crc = 7; §\C{// error, cannot change cx}§
     1813®&®crc = &cx; §\C{// error, cannot change crc}§
    18011814\end{cfa}
    18021815Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
    18031816\begin{cfa}
    1804 int & const cr = *0; $\C{// where 0 is the int * zero}$
     1817int & const cr = *0; §\C{// where 0 is the int * zero}§
    18051818\end{cfa}
    18061819Note, constant reference-types do not prevent \Index{addressing errors} because of explicit storage-management:
    … …  
    18091822cr = 5;
    18101823free( &cr );
    1811 cr = 7; $\C{// unsound pointer dereference}$
     1824cr = 7; §\C{// unsound pointer dereference}§
    18121825\end{cfa}
    18131826
    18141827The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
    18151828The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
    1816 \CFA-style declarations \see{\VRef{s:AlternativeDeclarations}} attempt to address this issue:
     1829\CFA-style declarations (see \VRef{s:AlternativeDeclarations}) attempt to address this issue:
    18171830\begin{cquote}
    18181831\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
    18191832\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
    18201833\begin{cfa}
    1821 @const@ * @const@ * const int ccp;
    1822 @const@ & @const@ & const int ccr;
     1834®const® * ®const® * const int ccp;
     1835®const® & ®const® & const int ccr;
    18231836\end{cfa}
    18241837&
    18251838\begin{cfa}
    1826 const int * @const@ * @const@ ccp;
     1839const int * ®const® * ®const® ccp;
    18271840
    18281841\end{cfa}
    … …  
    18331846Finally, like pointers, references are usable and composable with other type operators and generators.
    18341847\begin{cfa}
    1835 int w, x, y, z, & ar[3] = { x, y, z }; $\C{// initialize array of references}$
    1836 &ar[1] = &w; $\C{// change reference array element}$
    1837 typeof( ar[1] ) p; $\C{// (gcc) is int, \ie the type of referenced object}$
    1838 typeof( &ar[1] ) q; $\C{// (gcc) is int \&, \ie the type of reference}$
    1839 sizeof( ar[1] ) == sizeof( int ); $\C{// is true, \ie the size of referenced object}$
    1840 sizeof( &ar[1] ) == sizeof( int *) $\C{// is true, \ie the size of a reference}$
     1848int w, x, y, z, & ar[3] = { x, y, z }; §\C{// initialize array of references}§
     1849&ar[1] = &w; §\C{// change reference array element}§
     1850typeof( ar[1] ) p; §\C{// (gcc) is int, \ie the type of referenced object}§
     1851typeof( &ar[1] ) q; §\C{// (gcc) is int \&, \ie the type of reference}§
     1852sizeof( ar[1] ) == sizeof( int ); §\C{// is true, \ie the size of referenced object}§
     1853sizeof( &ar[1] ) == sizeof( int *) §\C{// is true, \ie the size of a reference}§
    18411854\end{cfa}
    18421855
    18431856In contrast to \CFA reference types, \Index*[C++]{\CC{}}'s reference types are all ©const© references, preventing changes to the reference address, so only value assignment is possible, which eliminates half of the \Index{address duality}.
    18441857Also, \CC does not allow \Index{array}s\index{array!reference} of reference\footnote{
    1845 The reason for disallowing arrays of reference is unknown, but possibly comes from references being ethereal (like a textual macro), and hence, replaceable by the referent object.}
     1858The reason for disallowing arrays of reference is unknown, but possibly comes from references being ethereal (like a textual macro), and hence, replaceable by the referant object.}
    18461859\Index*{Java}'s reference types to objects (all Java objects are on the heap) are like C pointers, which always manipulate the address, and there is no (bit-wise) object assignment, so objects are explicitly cloned by shallow or deep copying, which eliminates half of the address duality.
    18471860
    … …  
    18551868Therefore, for pointer/reference initialization, the initializing value must be an address not a value.
    18561869\begin{cfa}
    1857 int * p = &x; $\C{// assign address of x}$
    1858 @int * p = x;@ $\C{// assign value of x}$
    1859 int & r = x; $\C{// must have address of x}$
     1870int * p = &x; §\C{// assign address of x}§
     1871®int * p = x;® §\C{// assign value of x}§
     1872int & r = x; §\C{// must have address of x}§
    18601873\end{cfa}
    18611874Like the previous example with C pointer-arithmetic, it is unlikely assigning the value of ©x© into a pointer is meaningful (again, a warning is usually given).
    … …  
    18661879Similarly, when a reference type is used for a parameter/return type, the call-site argument does not require a reference operator for the same reason.
    18671880\begin{cfa}
    1868 int & f( int & r ); $\C{// reference parameter and return}$
    1869 z = f( x ) + f( y ); $\C{// reference operator added, temporaries needed for call results}$
     1881int & f( int & r ); §\C{// reference parameter and return}§
     1882z = f( x ) + f( y ); §\C{// reference operator added, temporaries needed for call results}§
    18701883\end{cfa}
    18711884Within routine ©f©, it is possible to change the argument by changing the corresponding parameter, and parameter ©r© can be locally reassigned within ©f©.
    … …  
    18801893When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
    18811894\begin{cfa}
    1882 void f( @const@ int & cr );
    1883 void g( @const@ int * cp );
    1884 f( 3 );                   g( @&@3 );
    1885 f( x + y );             g( @&@(x + y) );
     1895void f( ®const® int & cr );
     1896void g( ®const® int * cp );
     1897f( 3 );                   g( ®&®3 );
     1898f( x + y );             g( ®&®(x + y) );
    18861899\end{cfa}
    18871900Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter.
    … …  
    18941907void f( int & r );
    18951908void g( int * p );
    1896 f( 3 );                   g( @&@3 ); $\C{// compiler implicit generates temporaries}$
    1897 f( x + y );             g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$
     1909f( 3 );                   g( ®&®3 ); §\C{// compiler implicit generates temporaries}§
     1910f( x + y );             g( ®&®(x + y) ); §\C{// compiler implicit generates temporaries}§
    18981911\end{cfa}
    18991912Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
    … …  
    19061919\begin{cfa}
    19071920void f( int i );
    1908 void (* fp)( int ); $\C{// routine pointer}$
    1909 fp = f; $\C{// reference initialization}$
    1910 fp = &f; $\C{// pointer initialization}$
    1911 fp = *f; $\C{// reference initialization}$
    1912 fp(3); $\C{// reference invocation}$
    1913 (*fp)(3); $\C{// pointer invocation}$
     1921void (* fp)( int ); §\C{// routine pointer}§
     1922fp = f; §\C{// reference initialization}§
     1923fp = &f; §\C{// pointer initialization}§
     1924fp = *f; §\C{// reference initialization}§
     1925fp(3); §\C{// reference invocation}§
     1926(*fp)(3); §\C{// pointer invocation}§
    19141927\end{cfa}
    19151928While C's treatment of routine objects has similarity to inferring a reference type in initialization contexts, the examples are assignment not initialization, and all possible forms of assignment are possible (©f©, ©&f©, ©*f©) without regard for type.
    19161929Instead, a routine object should be referenced by a ©const© reference:
    19171930\begin{cfa}
    1918 @const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$
    1919 fr = ... $\C{// error, cannot change code}$
    1920 &fr = ...; $\C{// changing routine reference}$
    1921 fr( 3 ); $\C{// reference call to f}$
    1922 (*fr)(3); $\C{// error, incorrect type}$
     1931®const® void (®&® fr)( int ) = f; §\C{// routine reference}§
     1932fr = ... §\C{// error, cannot change code}§
     1933&fr = ...; §\C{// changing routine reference}§
     1934fr( 3 ); §\C{// reference call to f}§
     1935(*fr)(3); §\C{// error, incorrect type}§
    19231936\end{cfa}
    19241937because the value of the routine object is a routine literal, \ie the routine code is normally immutable during execution.\footnote{
    … …  
    19331946\begin{itemize}
    19341947\item
    1935 if ©R© is an \Index{rvalue} of type ©T &©$_1\cdots$ ©&©$_r$, where $r \ge 1$ references (©&© symbols), than ©&R© has type ©T ©\R{©*©}©&©\R{$_2$}$\cdots$ ©&©\R{$_r$}, \ie ©T© pointer with $r-1$ references (©&© symbols).
    1936 
    1937 \item
    1938 if ©L© is an \Index{lvalue} of type ©T &©$_1\cdots$ ©&©$_l$, where $l \ge 0$ references (©&© symbols), than ©&L© has type ©T ©\R{©*©}©&©\R{$_1$}$\cdots$ ©&©\R{$_l$}, \ie ©T© pointer with $l$ references (©&© symbols).
     1948if ©R© is an \Index{rvalue} of type ©T &©$_1\cdots$ ©&©$_r$, where $r \ge 1$ references (©&© symbols), than ©&R© has type ©T ®*®&©$_{\color{red}2}\cdots$ ©&©$_{\color{red}r}$, \ie ©T© pointer with $r-1$ references (©&© symbols).
     1949
     1950\item
     1951if ©L© is an \Index{lvalue} of type ©T &©$_1\cdots$ ©&©$_l$, where $l \ge 0$ references (©&© symbols), than ©&L© has type ©T ®*®&©$_{\color{red}1}\cdots$ ©&©$_{\color{red}l}$, \ie ©T© pointer with $l$ references (©&© symbols).
    19391952\end{itemize}
    19401953The following example shows the first rule applied to different \Index{rvalue} contexts:
    … …  
    19421955int x, * px, ** ppx, *** pppx, **** ppppx;
    19431956int & rx = x, && rrx = rx, &&& rrrx = rrx ;
    1944 x = rrrx; $\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$
    1945 px = &rrrx; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}$
    1946 ppx = &&rrrx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}$
    1947 pppx = &&&rrrx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}$
    1948 ppppx = &&&&rrrx; $\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}$
     1957x = rrrx; §\C[2.0in]{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
     1958px = &rrrx; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (\&x)}§
     1959ppx = &&rrrx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (\&rx)}§
     1960pppx = &&&rrrx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (\&rrx)}§
     1961ppppx = &&&&rrrx; §\C{// starting from \&\&\&rrrx, \&\&\&\&rrrx is an rvalue with type int **** (\&rrrx)}§
    19491962\end{cfa}
    19501963The following example shows the second rule applied to different \Index{lvalue} contexts:
    … …  
    19521965int x, * px, ** ppx, *** pppx;
    19531966int & rx = x, && rrx = rx, &&& rrrx = rrx ;
    1954 rrrx = 2; $\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}$
    1955 &rrrx = px; $\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}$
    1956 &&rrrx = ppx; $\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}$
    1957 &&&rrrx = pppx; $\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT$
     1967rrrx = 2; §\C{// rrrx is an lvalue with type int \&\&\& (equivalent to x)}§
     1968&rrrx = px; §\C{// starting from rrrx, \&rrrx is an rvalue with type int *\&\&\& (rx)}§
     1969&&rrrx = ppx; §\C{// starting from \&rrrx, \&\&rrrx is an rvalue with type int **\&\& (rrx)}§
     1970&&&rrrx = pppx; §\C{// starting from \&\&rrrx, \&\&\&rrrx is an rvalue with type int ***\& (rrrx)}\CRT§
    19581971\end{cfa}
    19591972
    … …  
    19681981\begin{cfa}
    19691982int x;
    1970 x + 1; $\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}$
     1983x + 1; §\C[2.0in]{// lvalue variable (int) converts to rvalue for expression}§
    19711984\end{cfa}
    19721985An rvalue has no type qualifiers (©cv©), so the lvalue qualifiers are dropped.
    … …  
    19781991\begin{cfa}
    19791992int x, &r = x, f( int p );
    1980 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$
     1993x = ®r® + f( ®r® ); §\C{// lvalue reference converts to rvalue}§
    19811994\end{cfa}
    19821995An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
    … …  
    19851998lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
    19861999\begin{cfa}
    1987 int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
    1988 f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$
     2000int x, &r = ®x®, f( int & p ); §\C{// lvalue variable (int) convert to reference (int \&)}§
     2001f( ®x® ); §\C{// lvalue variable (int) convert to reference (int \&)}§
    19892002\end{cfa}
    19902003Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
    … …  
    19962009\begin{cfa}
    19972010int x, & f( int & p );
    1998 f( @x + 3@ );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
    1999 @&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
     2011f( ®x + 3® );   §\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}§
     2012®&f®(...) = &x; §\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT§
    20002013\end{cfa}
    20012014In both case, modifications to the temporary are inaccessible (\Index{warning}).
    … …  
    21692182The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
    21702183\begin{cfa}
    2171 @[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) {
    2172         $\emph{routine body}$
     2184®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
     2185        §\emph{routine body}§
    21732186}
    21742187\end{cfa}
    … …  
    21812194Declaration qualifiers can only appear at the start of a routine definition, \eg:
    21822195\begin{cfa}
    2183 @extern@ [ int x ] g( int y ) {$\,$}
     2196®extern® [ int x ] g( int y ) {§\,§}
    21842197\end{cfa}
    21852198Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
    21862199in both cases the type is assumed to be void as opposed to old style C defaults of int return type and unknown parameter types, respectively, as in:
    21872200\begin{cfa}
    2188 [$\,$] g(); $\C{// no input or output parameters}$
    2189 [ void ] g( void ); $\C{// no input or output parameters}$
     2201[§\,§] g(); §\C{// no input or output parameters}§
     2202[ void ] g( void ); §\C{// no input or output parameters}§
    21902203\end{cfa}
    21912204
    … …  
    22052218\begin{cfa}
    22062219typedef int foo;
    2207 int f( int (* foo) ); $\C{// foo is redefined as a parameter name}$
     2220int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§
    22082221\end{cfa}
    22092222The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
    … …  
    22132226C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
    22142227\begin{cfa}
    2215 [ int ] f( * int, int * ); $\C{// returns an integer, accepts 2 pointers to integers}$
    2216 [ * int, int * ] f( int ); $\C{// returns 2 pointers to integers, accepts an integer}$
     2228[ int ] f( * int, int * ); §\C{// returns an integer, accepts 2 pointers to integers}§
     2229[ * int, int * ] f( int ); §\C{// returns 2 pointers to integers, accepts an integer}§
    22172230\end{cfa}
    22182231The reason for allowing both declaration styles in the new context is for backwards compatibility with existing preprocessor macros that generate C-style declaration-syntax, as in:
    22192232\begin{cfa}
    22202233#define ptoa( n, d ) int (*n)[ d ]
    2221 int f( ptoa( p, 5 ) ) ... $\C{// expands to int f( int (*p)[ 5 ] )}$
    2222 [ int ] f( ptoa( p, 5 ) ) ... $\C{// expands to [ int ] f( int (*p)[ 5 ] )}$
     2234int f( ptoa( p, 5 ) ) ... §\C{// expands to int f( int (*p)[ 5 ] )}§
     2235[ int ] f( ptoa( p, 5 ) ) ... §\C{// expands to [ int ] f( int (*p)[ 5 ] )}§
    22232236\end{cfa}
    22242237Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
    … …  
    22392252\begin{minipage}{\linewidth}
    22402253\begin{cfa}
    2241 @[ int x, int y ]@ f() {
     2254®[ int x, int y ]® f() {
    22422255        int z;
    22432256        ... x = 0; ... y = z; ...
    2244         @return;@ $\C{// implicitly return x, y}$
     2257        ®return;® §\C{// implicitly return x, y}§
    22452258}
    22462259\end{cfa}
    … …  
    22522265[ int x, int y ] f() {
    22532266        ...
    2254 } $\C{// implicitly return x, y}$
     2267} §\C{// implicitly return x, y}§
    22552268\end{cfa}
    22562269In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
    … …  
    22612274[ int x, int y ] f( int, x, int y ) {
    22622275        ...
    2263 } $\C{// implicitly return x, y}$
     2276} §\C{// implicitly return x, y}§
    22642277\end{cfa}
    22652278This notation allows the compiler to eliminate temporary variables in nested routine calls.
    22662279\begin{cfa}
    2267 [ int x, int y ] f( int, x, int y ); $\C{// prototype declaration}$
     2280[ int x, int y ] f( int, x, int y ); §\C{// prototype declaration}§
    22682281int a, b;
    22692282[a, b] = f( f( f( a, b ) ) );
    … …  
    22792292as well, parameter names are optional, \eg:
    22802293\begin{cfa}
    2281 [ int x ] f (); $\C{// returning int with no parameters}$
    2282 [ * int ] g (int y); $\C{// returning pointer to int with int parameter}$
    2283 [ ] h ( int, char ); $\C{// returning no result with int and char parameters}$
    2284 [ * int, int ] j ( int ); $\C{// returning pointer to int and int, with int parameter}$
     2294[ int x ] f (); §\C{// returning int with no parameters}§
     2295[ * int ] g (int y); §\C{// returning pointer to int with int parameter}§
     2296[ ] h ( int, char ); §\C{// returning no result with int and char parameters}§
     2297[ * int, int ] j ( int ); §\C{// returning pointer to int and int, with int parameter}§
    22852298\end{cfa}
    22862299This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
    2287 Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list \see{\VRef{s:AlternativeDeclarations}}, \eg:
     2300Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:AlternativeDeclarations}), \eg:
    22882301\begin{cfa}
    22892302C :             const double bar1(), bar2( int ), bar3( double );
    2290 $\CFA$: [const double] foo(), foo( int ), foo( double ) { return 3.0; }
     2303§\CFA§: [const double] foo(), foo( int ), foo( double ) { return 3.0; }
    22912304\end{cfa}
    22922305\CFA allows the last routine in the list to define its body.
    … …  
    23032316The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
    23042317\begin{cfa}
    2305 * [ int x ] () fp; $\C[2.25in]{// pointer to routine returning int with no parameters}$
    2306 * [ * int ] (int y) gp; $\C{// pointer to routine returning pointer to int with int parameter}$
    2307 * [ ] (int,char) hp; $\C{// pointer to routine returning no result with int and char parameters}$
    2308 * [ * int,int ] ( int ) jp; $\C{// pointer to routine returning pointer to int and int, with int parameter}\CRT$
     2318* [ int x ] () fp; §\C{// pointer to routine returning int with no parameters}§
     2319* [ * int ] (int y) gp; §\C{// pointer to routine returning pointer to int with int parameter}§
     2320* [ ] (int,char) hp; §\C{// pointer to routine returning no result with int and char parameters}§
     2321* [ * int,int ] ( int ) jp; §\C{// pointer to routine returning pointer to int and int, with int parameter}§
    23092322\end{cfa}
    23102323While parameter names are optional, \emph{a routine name cannot be specified};
    23112324for example, the following is incorrect:
    23122325\begin{cfa}
    2313 * [ int x ] f () fp; $\C{// routine name "f" is not allowed}$
     2326* [ int x ] f () fp; §\C{// routine name "f" is not allowed}§
    23142327\end{cfa}
    23152328
    … …  
    23342347whereas a named (keyword) call may be:
    23352348\begin{cfa}
    2336 p( z : 3, x : 4, y : 7 );  $\C{// rewrite \(\Rightarrow\) p( 4, 7, 3 )}$
     2349p( z : 3, x : 4, y : 7 );  §\C{// rewrite $\Rightarrow$ p( 4, 7, 3 )}§
    23372350\end{cfa}
    23382351Here the order of the arguments is unimportant, and the names of the parameters are used to associate argument values with the corresponding parameters.
    … …  
    23512364For example, the following routine prototypes and definition are all valid.
    23522365\begin{cfa}
    2353 void p( int, int, int ); $\C{// equivalent prototypes}$
     2366void p( int, int, int ); §\C{// equivalent prototypes}§
    23542367void p( int x, int y, int z );
    23552368void p( int y, int x, int z );
    23562369void p( int z, int y, int x );
    2357 void p( int q, int r, int s ) {} $\C{// match with this definition}$
     2370void p( int q, int r, int s ) {} §\C{// match with this definition}§
    23582371\end{cfa}
    23592372Forcing matching parameter names in routine prototypes with corresponding routine definitions is possible, but goes against a strong tradition in C programming.
    … …  
    23672380int f( int x, double y );
    23682381
    2369 f( j : 3, i : 4 ); $\C{// 1st f}$
    2370 f( x : 7, y : 8.1 ); $\C{// 2nd f}$
    2371 f( 4, 5 );  $\C{// ambiguous call}$
     2382f( j : 3, i : 4 ); §\C{// 1st f}§
     2383f( x : 7, y : 8.1 ); §\C{// 2nd f}§
     2384f( 4, 5 );  §\C{// ambiguous call}§
    23722385\end{cfa}
    23732386However, named arguments compound routine resolution in conjunction with conversions:
    23742387\begin{cfa}
    2375 f( i : 3, 5.7 ); $\C{// ambiguous call ?}$
     2388f( i : 3, 5.7 ); §\C{// ambiguous call ?}§
    23762389\end{cfa}
    23772390Depending on the cost associated with named arguments, this call could be resolvable or ambiguous.
    … …  
    23872400the allowable positional calls are:
    23882401\begin{cfa}
    2389 p(); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$
    2390 p( 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$
    2391 p( 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$
    2392 p( 4, 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 4 )}$
     2402p(); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
     2403p( 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
     2404p( 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
     2405p( 4, 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 4 )}§
    23932406// empty arguments
    2394 p(  , 4, 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 4 )}$
    2395 p( 4,  , 4 ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 4 )}$
    2396 p( 4, 4,   ); $\C{// rewrite \(\Rightarrow\) p( 4, 4, 3 )}$
    2397 p( 4,  ,   ); $\C{// rewrite \(\Rightarrow\) p( 4, 2, 3 )}$
    2398 p(  , 4,   ); $\C{// rewrite \(\Rightarrow\) p( 1, 4, 3 )}$
    2399 p(  ,  , 4 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 4 )}$
    2400 p(  ,  ,   ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 3 )}$
     2407p(  , 4, 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 4 )}§
     2408p( 4,  , 4 ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 4 )}§
     2409p( 4, 4,   ); §\C{// rewrite $\Rightarrow$ p( 4, 4, 3 )}§
     2410p( 4,  ,   ); §\C{// rewrite $\Rightarrow$ p( 4, 2, 3 )}§
     2411p(  , 4,   ); §\C{// rewrite $\Rightarrow$ p( 1, 4, 3 )}§
     2412p(  ,  , 4 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 4 )}§
     2413p(  ,  ,   ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 3 )}§
    24012414\end{cfa}
    24022415Here the missing arguments are inserted from the default values in the parameter list.
    … …  
    24222435Default values may only appear in a prototype versus definition context:
    24232436\begin{cfa}
    2424 void p( int x, int y = 2, int z = 3 ); $\C{// prototype: allowed}$
    2425 void p( int, int = 2, int = 3 ); $\C{// prototype: allowed}$
    2426 void p( int x, int y = 2, int z = 3 ) {} $\C{// definition: not allowed}$
     2437void p( int x, int y = 2, int z = 3 ); §\C{// prototype: allowed}§
     2438void p( int, int = 2, int = 3 ); §\C{// prototype: allowed}§
     2439void p( int x, int y = 2, int z = 3 ) {} §\C{// definition: not allowed}§
    24272440\end{cfa}
    24282441The reason for this restriction is to allow separate compilation.
    … …  
    24392452\begin{cfa}
    24402453p( int x, int y, int z, ... );
    2441 p( 1, 4, 5, 6, z : 3, y : 2 ); $\C{// assume p( /* positional */, ... , /* named */ );}$
    2442 p( 1, z : 3, y : 2, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$
     2454p( 1, 4, 5, 6, z : 3, y : 2 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
     2455p( 1, z : 3, y : 2, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
    24432456\end{cfa}
    24442457In the first call, it is necessary for the programmer to conceptually rewrite the call, changing named arguments into positional, before knowing where the ellipse arguments begin.
    … …  
    24492462\begin{cfa}
    24502463void p( int x, int y = 2, int z = 3... );
    2451 p( 1, 4, 5, 6, z : 3 ); $\C{// assume p( /* positional */, ... , /* named */ );}$
    2452 p( 1, z : 3, 4, 5, 6 ); $\C{// assume p( /* positional */, /* named */, ... );}$
     2464p( 1, 4, 5, 6, z : 3 ); §\C{// assume p( /* positional */, ... , /* named */ );}§
     2465p( 1, z : 3, 4, 5, 6 ); §\C{// assume p( /* positional */, /* named */, ... );}§
    24532466\end{cfa}
    24542467The first call is an error because arguments 4 and 5 are actually positional not ellipse arguments;
    … …  
    24562469In the second call, the default value for y is implicitly inserted after argument 1 and the named arguments separate the positional and ellipse arguments, making it trivial to read the call.
    24572470For these reasons, \CFA requires named arguments before ellipse arguments.
    2458 Finally, while ellipse arguments are needed for a small set of existing C routines, like ©printf©, the extended \CFA type system largely eliminates the need for ellipse arguments \see{\VRef{s:Overloading}}, making much of this discussion moot.
    2459 
    2460 Default arguments and overloading \see{\VRef{s:Overloading}} are complementary.
     2471Finally, while ellipse arguments are needed for a small set of existing C routines, like printf, the extended \CFA type system largely eliminates the need for ellipse arguments (see Section 24), making much of this discussion moot.
     2472
     2473Default arguments and overloading (see Section 24) are complementary.
    24612474While in theory default arguments can be simulated with overloading, as in:
    24622475\begin{cquote}
    … …  
    24802493Furthermore, overloading cannot handle accessing default arguments in the middle of a positional list, via a missing argument, such as:
    24812494\begin{cfa}
    2482 p( 1, /* default */, 5 ); $\C{// rewrite \(\Rightarrow\) p( 1, 2, 5 )}$
     2495p( 1, /* default */, 5 ); §\C{// rewrite $\Rightarrow$ p( 1, 2, 5 )}§
    24832496\end{cfa}
    24842497
    … …  
    24932506\begin{cfa}
    24942507struct {
    2495         int f1; $\C{// named field}$
    2496         int f2 : 4; $\C{// named field with bit field size}$
    2497         int : 3; $\C{// unnamed field for basic type with bit field size}$
    2498         int ; $\C{// disallowed, unnamed field}$
    2499         int *; $\C{// disallowed, unnamed field}$
    2500         int (*)( int ); $\C{// disallowed, unnamed field}$
     2508        int f1; §\C{// named field}§
     2509        int f2 : 4; §\C{// named field with bit field size}§
     2510        int : 3; §\C{// unnamed field for basic type with bit field size}§
     2511        int ; §\C{// disallowed, unnamed field}§
     2512        int *; §\C{// disallowed, unnamed field}§
     2513        int (*)( int ); §\C{// disallowed, unnamed field}§
    25012514};
    25022515\end{cfa}
    … …  
    25062519\begin{cfa}
    25072520struct {
    2508         int , , ; $\C{// 3 unnamed fields}$
     2521        int , , ; §\C{// 3 unnamed fields}§
    25092522}
    25102523\end{cfa}
    … …  
    25182531\subsection{Type Nesting}
    25192532
    2520 \CFA allows \Index{type nesting}, and type qualification of the nested types \see{\VRef[Figure]{f:TypeNestingQualification}}, where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
     2533\CFA allows \Index{type nesting}, and type qualification of the nested types (see \VRef[Figure]{f:TypeNestingQualification}), where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
    25212534\begin{figure}
    25222535\centering
    … …  
    25742587
    25752588int fred() {
    2576         s.t.c = @S.@R;  // type qualification
    2577         struct @S.@T t = { @S.@R, 1, 2 };
    2578         enum @S.@C c;
    2579         union @S.T.@U u;
     2589        s.t.c = ®S.®R;  // type qualification
     2590        struct ®S.®T t = { ®S.®R, 1, 2 };
     2591        enum ®S.®C c;
     2592        union ®S.T.®U u;
    25802593}
    25812594\end{cfa}
    … …  
    26002613const unsigned int size = 5;
    26012614int ia[size];
    2602 ... $\C{// assign values to array ia}$
    2603 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
     2615... §\C{// assign values to array ia}§
     2616qsort( ia, size ); §\C{// sort ascending order using builtin ?<?}§
    26042617{
    2605         @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$
    2606         qsort( ia, size ); $\C{// sort descending order by local redefinition}$
     2618        ®int ?<?( int x, int y ) { return x > y; }® §\C{// nested routine}§
     2619        qsort( ia, size ); §\C{// sort descending order by local redefinition}§
    26072620}
    26082621\end{cfa}
    … …  
    26122625The following program in undefined in \CFA (and Indexc{gcc})
    26132626\begin{cfa}
    2614 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$
    2615         int @i@ = 7;
     2627[* [int]( int )] foo() { §\C{// int (* foo())( int )}§
     2628        int ®i® = 7;
    26162629        int bar( int p ) {
    2617                 @i@ += 1; $\C{// dependent on local variable}$
    2618                 sout | @i@;
     2630                ®i® += 1; §\C{// dependent on local variable}§
     2631                sout | ®i®;
    26192632        }
    2620         return bar; $\C{// undefined because of local dependence}$
     2633        return bar; §\C{// undefined because of local dependence}§
    26212634}
    26222635int main() {
    2623         * [int]( int ) fp = foo(); $\C{// int (* fp)( int )}$
     2636        * [int]( int ) fp = foo(); §\C{// int (* fp)( int )}§
    26242637        sout | fp( 3 );
    26252638}
    … …  
    26342647In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
    26352648\begin{cfa}
    2636 f( @2, x, 3 + i@ ); $\C{// element list}$
     2649f( ®2, x, 3 + i® ); §\C{// element list}§
    26372650\end{cfa}
    26382651A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
    … …  
    26432656
    26442657In C and most programming languages, functions return at most one value;
    2645 however, many operations have multiple outcomes, some exceptional \see{\VRef{s:ExceptionHandling}}.
     2658however, many operations have multiple outcomes, some exceptional (see~\VRef{s:ExceptionHandling}).
    26462659To emulate functions with multiple return values, \emph{\Index{aggregation}} and/or \emph{\Index{aliasing}} is used.
    26472660
    … …  
    26492662For example, consider C's \Indexc{div} function, which returns the quotient and remainder for a division of an integer value.
    26502663\begin{cfa}
    2651 typedef struct { int quot, rem; } div_t;        $\C[7cm]{// from include stdlib.h}$
     2664typedef struct { int quot, rem; } div_t;        §\C[7cm]{// from include stdlib.h}§
    26522665div_t div( int num, int den );
    2653 div_t qr = div( 13, 5 ); $\C{// return quotient/remainder aggregate}$
    2654 printf( "%d %d\n", qr.quot, qr.rem ); $\C{// print quotient/remainder}$
     2666div_t qr = div( 13, 5 ); §\C{// return quotient/remainder aggregate}§
     2667printf( "%d %d\n", qr.quot, qr.rem ); §\C{// print quotient/remainder}§
    26552668\end{cfa}
    26562669This approach requires a name for the return type and fields, where \Index{naming} is a common programming-language issue.
    … …  
    26622675For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
    26632676\begin{cfa}
    2664 double modf( double x, double * i ); $\C{// from include math.h}$
    2665 double intp, frac = modf( 13.5, &intp ); $\C{// return integral and fractional components}$
    2666 printf( "%g %g\n", intp, frac ); $\C{// print integral/fractional components}$
     2677double modf( double x, double * i ); §\C{// from include math.h}§
     2678double intp, frac = modf( 13.5, &intp ); §\C{// return integral and fractional components}§
     2679printf( "%g %g\n", intp, frac ); §\C{// print integral/fractional components}§
    26672680\end{cfa}
    26682681This approach requires allocating storage for the return values, which complicates the call site with a sequence of variable declarations leading to the call.
    … …  
    26912704When a function call is passed as an argument to another call, the best match of actual arguments to formal parameters is evaluated given all possible expression interpretations in the current scope.
    26922705\begin{cfa}
    2693 void g( int, int ); $\C{// 1}$
    2694 void g( double, double ); $\C{// 2}$
    2695 g( div( 13, 5 ) ); $\C{// select 1}$
    2696 g( modf( 13.5 ) ); $\C{// select 2}$
     2706void g( int, int ); §\C{// 1}§
     2707void g( double, double ); §\C{// 2}§
     2708g( div( 13, 5 ) ); §\C{// select 1}§
     2709g( modf( 13.5 ) ); §\C{// select 2}§
    26972710\end{cfa}
    26982711In this case, there are two overloaded ©g© routines.
    … …  
    27032716The previous examples can be rewritten passing the multiple returned-values directly to the ©printf© function call.
    27042717\begin{cfa}
    2705 [ int, int ] div( int x, int y ); $\C{// from include stdlib}$
    2706 printf( "%d %d\n", div( 13, 5 ) ); $\C{// print quotient/remainder}$
    2707 
    2708 [ double, double ] modf( double x ); $\C{// from include math}$
    2709 printf( "%g %g\n", modf( 13.5 ) ); $\C{// print integral/fractional components}$
     2718[ int, int ] div( int x, int y ); §\C{// from include stdlib}§
     2719printf( "%d %d\n", div( 13, 5 ) ); §\C{// print quotient/remainder}§
     2720
     2721[ double, double ] modf( double x ); §\C{// from include math}§
     2722printf( "%g %g\n", modf( 13.5 ) ); §\C{// print integral/fractional components}§
    27102723\end{cfa}
    27112724This approach provides the benefits of compile-time checking for appropriate return statements as in aggregation, but without the required verbosity of declaring a new named type.
    … …  
    27172730\begin{cfa}
    27182731int quot, rem;
    2719 [ quot, rem ] = div( 13, 5 ); $\C{// assign multiple variables}$
    2720 printf( "%d %d\n", quot, rem ); $\C{// print quotient/remainder}\CRT$
     2732[ quot, rem ] = div( 13, 5 ); §\C{// assign multiple variables}§
     2733printf( "%d %d\n", quot, rem ); §\C{// print quotient/remainder}\CRT§
    27212734\end{cfa}
    27222735Here, the multiple return-values are matched in much the same way as passing multiple return-values to multiple parameters in a call.
    … …  
    27472760In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
    27482761\begin{cfa}
    2749 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$
    2750 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$
     2762[int, int] ®qr® = div( 13, 5 ); §\C{// initialize tuple variable}§
     2763printf( "%d %d\n", ®qr® ); §\C{// print quotient/remainder}§
    27512764\end{cfa}
    27522765It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
    … …  
    27542767One way to access the individual components of a tuple variable is with assignment.
    27552768\begin{cfa}
    2756 [ quot, rem ] = qr; $\C{// assign multiple variables}$
     2769[ quot, rem ] = qr; §\C{// assign multiple variables}§
    27572770\end{cfa}
    27582771
    … …  
    27772790[int, double] * p;
    27782791
    2779 int y = x.0; $\C{// access int component of x}$
    2780 y = f().1; $\C{// access int component of f}$
    2781 p->0 = 5; $\C{// access int component of tuple pointed-to by p}$
    2782 g( x.1, x.0 ); $\C{// rearrange x to pass to g}$
    2783 double z = [ x, f() ].0.1; $\C{// access second component of first component of tuple expression}$
     2792int y = x.0; §\C{// access int component of x}§
     2793y = f().1; §\C{// access int component of f}§
     2794p->0 = 5; §\C{// access int component of tuple pointed-to by p}§
     2795g( x.1, x.0 ); §\C{// rearrange x to pass to g}§
     2796double z = [ x, f() ].0.1; §\C{// access second component of first component of tuple expression}§
    27842797\end{cfa}
    27852798Tuple-index expressions can occur on any tuple-typed expression, including tuple-returning functions, square-bracketed tuple expressions, and other tuple-index expressions, provided the retrieved component is also a tuple.
    … …  
    27882801
    27892802\subsection{Flattening and Structuring}
    2790 \label{s:FlatteningStructuring}
    27912803
    27922804As evident in previous examples, tuples in \CFA do not have a rigid structure.
    … …  
    28492861double y;
    28502862[int, double] z;
    2851 [y, x] = 3.14; $\C{// mass assignment}$
    2852 [x, y] = z;                                                         $\C{// multiple assignment}$
    2853 z = 10;                                                         $\C{// mass assignment}$
    2854 z = [x, y]; $\C{// multiple assignment}$
     2863[y, x] = 3.14; §\C{// mass assignment}§
     2864[x, y] = z;                                                         §\C{// multiple assignment}§
     2865z = 10;                                                         §\C{// mass assignment}§
     2866z = [x, y]; §\C{// multiple assignment}§
    28552867\end{cfa}
    28562868Let $L_i$ for $i$ in $[0, n)$ represent each component of the flattened left side, $R_i$ represent each component of the flattened right side of a multiple assignment, and $R$ represent the right side of a mass assignment.
    … …  
    28602872\begin{cfa}
    28612873[ int, int ] x, y, z;
    2862 [ x, y ] = z;                                              $\C{// multiple assignment, invalid 4 != 2}$
     2874[ x, y ] = z;                                              §\C{// multiple assignment, invalid 4 != 2}§
    28632875\end{cfa}
    28642876Multiple assignment assigns $R_i$ to $L_i$ for each $i$.
    … …  
    28962908        double c, d;
    28972909        [ void ] f( [ int, int ] );
    2898         f( [ c, a ] = [ b, d ] = 1.5 ); $\C{// assignments in parameter list}$
     2910        f( [ c, a ] = [ b, d ] = 1.5 ); §\C{// assignments in parameter list}§
    28992911\end{cfa}
    29002912The tuple expression begins with a mass assignment of ©1.5© into ©[b, d]©, which assigns ©1.5© into ©b©, which is truncated to ©1©, and ©1.5© into ©d©, producing the tuple ©[1, 1.5]© as a result.
    … …  
    29092921\begin{cfa}
    29102922struct S;
    2911 void ?{}(S *); $\C{// (1)}$
    2912 void ?{}(S *, int); $\C{// (2)}$
    2913 void ?{}(S * double); $\C{// (3)}$
    2914 void ?{}(S *, S); $\C{// (4)}$
    2915 
    2916 [S, S] x = [3, 6.28]; $\C{// uses (2), (3), specialized constructors}$
    2917 [S, S] y; $\C{// uses (1), (1), default constructor}$
    2918 [S, S] z = x.0; $\C{// uses (4), (4), copy constructor}$
     2923void ?{}(S *); §\C{// (1)}§
     2924void ?{}(S *, int); §\C{// (2)}§
     2925void ?{}(S * double); §\C{// (3)}§
     2926void ?{}(S *, S); §\C{// (4)}§
     2927
     2928[S, S] x = [3, 6.28]; §\C{// uses (2), (3), specialized constructors}§
     2929[S, S] y; §\C{// uses (1), (1), default constructor}§
     2930[S, S] z = x.0; §\C{// uses (4), (4), copy constructor}§
    29192931\end{cfa}
    29202932In this example, ©x© is initialized by the multiple constructor calls ©?{}(&x.0, 3)© and ©?{}(&x.1, 6.28)©, while ©y© is initialized by two default constructor calls ©?{}(&y.0)© and ©?{}(&y.1)©.
    … …  
    29572969A member-access tuple may be used anywhere a tuple can be used, \eg:
    29582970\begin{cfa}
    2959 s.[ y, z, x ] = [ 3, 3.2, 'x' ]; $\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}$
    2960 f( s.[ y, z ] ); $\C{// equivalent to f( s.y, s.z )}$
     2971s.[ y, z, x ] = [ 3, 3.2, 'x' ]; §\C{// equivalent to s.x = 'x', s.y = 3, s.z = 3.2}§
     2972f( s.[ y, z ] ); §\C{// equivalent to f( s.y, s.z )}§
    29612973\end{cfa}
    29622974Note, the fields appearing in a record-field tuple may be specified in any order;
    … …  
    29682980void f( double, long );
    29692981
    2970 f( x.[ 0, 3 ] ); $\C{// f( x.0, x.3 )}$
    2971 x.[ 0, 1 ] = x.[ 1, 0 ]; $\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}$
     2982f( x.[ 0, 3 ] ); §\C{// f( x.0, x.3 )}§
     2983x.[ 0, 1 ] = x.[ 1, 0 ]; §\C{// [ x.0, x.1 ] = [ x.1, x.0 ]}§
    29722984[ long, int, long ] y = x.[ 2, 0, 2 ];
    29732985\end{cfa}
    … …  
    29862998\begin{cfa}
    29872999[ int, float, double ] f();
    2988 [ double, float ] x = f().[ 2, 1 ]; $\C{// f() called once}$
     3000[ double, float ] x = f().[ 2, 1 ]; §\C{// f() called once}§
    29893001\end{cfa}
    29903002
    … …  
    29993011That is, a cast can be used to select the type of an expression when it is ambiguous, as in the call to an overloaded function.
    30003012\begin{cfa}
    3001 int f(); $\C{// (1)}$
    3002 double f(); $\C{// (2)}$
    3003 
    3004 f(); $\C{// ambiguous - (1),(2) both equally viable}$
    3005 (int)f(); $\C{// choose (2)}$
     3013int f(); §\C{// (1)}§
     3014double f(); §\C{// (2)}§
     3015
     3016f(); §\C{// ambiguous - (1),(2) both equally viable}§
     3017(int)f(); §\C{// choose (2)}§
    30063018\end{cfa}
    30073019Since casting is a fundamental operation in \CFA, casts need to be given a meaningful interpretation in the context of tuples.
    … …  
    30113023void g();
    30123024
    3013 (void)f(); $\C{// valid, ignore results}$
    3014 (int)g(); $\C{// invalid, void cannot be converted to int}$
     3025(void)f(); §\C{// valid, ignore results}§
     3026(int)g(); §\C{// invalid, void cannot be converted to int}§
    30153027
    30163028struct A { int x; };
    3017 (struct A)f(); $\C{// invalid, int cannot be converted to A}$
     3029(struct A)f(); §\C{// invalid, int cannot be converted to A}§
    30183030\end{cfa}
    30193031In C, line 4 is a valid cast, which calls ©f© and discards its result.
    … …  
    30313043        [int, [int, int], int] g();
    30323044
    3033         ([int, double])f(); $\C{// (1) valid}$
    3034         ([int, int, int])g(); $\C{// (2) valid}$
    3035         ([void, [int, int]])g(); $\C{// (3) valid}$
    3036         ([int, int, int, int])g(); $\C{// (4) invalid}$
    3037         ([int, [int, int, int]])g(); $\C{// (5) invalid}$
     3045        ([int, double])f(); §\C{// (1) valid}§
     3046        ([int, int, int])g(); §\C{// (2) valid}§
     3047        ([void, [int, int]])g(); §\C{// (3) valid}§
     3048        ([int, int, int, int])g(); §\C{// (4) invalid}§
     3049        ([int, [int, int, int]])g(); §\C{// (5) invalid}§
    30383050\end{cfa}
    30393051
    … …  
    30953107void f([int, int], int, int);
    30963108
    3097 f([0, 0], 0, 0); $\C{// no cost}$
    3098 f(0, 0, 0, 0); $\C{// cost for structuring}$
    3099 f([0, 0,], [0, 0]); $\C{// cost for flattening}$
    3100 f([0, 0, 0], 0); $\C{// cost for flattening and structuring}$
     3109f([0, 0], 0, 0); §\C{// no cost}§
     3110f(0, 0, 0, 0); §\C{// cost for structuring}§
     3111f([0, 0,], [0, 0]); §\C{// cost for flattening}§
     3112f([0, 0, 0], 0); §\C{// cost for flattening and structuring}§
    31013113\end{cfa}
    31023114
    … …  
    31343146The general syntax of a lexical list is:
    31353147\begin{cfa}
    3136 [ $\emph{exprlist}$ ]
     3148[ §\emph{exprlist}§ ]
    31373149\end{cfa}
    31383150where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
    … …  
    31463158Tuples are permitted to contain sub-tuples (\ie nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple.
    31473159Note, a tuple is not a record (structure);
    3148 a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure \see{flattening coercion in \VRef{s:FlatteningStructuring}}.
     3160a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure (see flattening coercion in Section 12.1).
    31493161In essence, tuples are largely a compile time phenomenon, having little or no runtime presence.
    31503162
    … …  
    31543166The general syntax of a tuple type is:
    31553167\begin{cfa}
    3156 [ $\emph{typelist}$ ]
     3168[ §\emph{typelist}§ ]
    31573169\end{cfa}
    31583170where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
    … …  
    31613173[ unsigned int, char ]
    31623174[ double, double, double ]
    3163 [ * int, int * ] $\C{// mix of CFA and ANSI}$
     3175[ * int, int * ] §\C{// mix of CFA and ANSI}§
    31643176[ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
    31653177\end{cfa}
    … …  
    31683180Examples of declarations using tuple types are:
    31693181\begin{cfa}
    3170 [ int, int ] x; $\C{// 2 element tuple, each element of type int}$
    3171 * [ char, char ] y; $\C{// pointer to a 2 element tuple}$
     3182[ int, int ] x; §\C{// 2 element tuple, each element of type int}§
     3183* [ char, char ] y; §\C{// pointer to a 2 element tuple}§
    31723184[ [ int, int ] ] z ([ int, int ]);
    31733185\end{cfa}
    … …  
    31863198[ int, int ] w1;
    31873199[ int, int, int ] w2;
    3188 [ void ] f (int, int, int); $\C{// three input parameters of type int}$
    3189 [ void ] g ([ int, int, int ]); $\C{3 element tuple as input}$
     3200[ void ] f (int, int, int); §\C{// three input parameters of type int}§
     3201[ void ] g ([ int, int, int ]); §\C{3 element tuple as input}§
    31903202f( [ 1, 2, 3 ] );
    31913203f( w1, 3 );
    … …  
    32673279[ int, int, int, int ] w = [ 1, 2, 3, 4 ];
    32683280int x = 5;
    3269 [ x, w ] = [ w, x ]; $\C{// all four tuple coercions}$
     3281[ x, w ] = [ w, x ]; §\C{// all four tuple coercions}§
    32703282\end{cfa}
    32713283Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
    … …  
    32733285This tuple is then flattened, yielding ©[ 1, 2, 3, 4, 5 ]©, which is structured into ©[ 1, [ 2, 3, 4, 5 ] ]© to match the tuple type of the left-hand side.
    32743286The tuple ©[ 2, 3, 4, 5 ]© is then closed to create a tuple value.
    3275 Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using \Index{multiple assignment} \see{\VRef{s:TupleAssignment}}.
     3287Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using multiple assignment (see Section 14).
    32763288\begin{rationale}
    32773289A possible additional language extension is to use the structuring coercion for tuples to initialize a complex record with a tuple.
    … …  
    32843296Mass assignment has the following form:
    32853297\begin{cfa}
    3286 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = $\emph{expr}$;
     3298[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
    32873299\end{cfa}
    32883300\index{lvalue}
    … …  
    33243336Multiple assignment has the following form:
    33253337\begin{cfa}
    3326 [ $\emph{lvalue}$, ... , $\emph{lvalue}$ ] = [ $\emph{expr}$, ... , $\emph{expr}$ ];
     3338[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
    33273339\end{cfa}
    33283340\index{lvalue}
    … …  
    33553367both these examples produce indeterminate results:
    33563368\begin{cfa}
    3357 f( x++, x++ ); $\C{// C routine call with side effects in arguments}$
    3358 [ v1, v2 ] = [ x++, x++ ]; $\C{// side effects in right-hand side of multiple assignment}$
     3369f( x++, x++ ); §\C{// C routine call with side effects in arguments}§
     3370[ v1, v2 ] = [ x++, x++ ]; §\C{// side effects in righthand side of multiple assignment}§
    33593371\end{cfa}
    33603372
    … …  
    33653377Cascade assignment has the following form:
    33663378\begin{cfa}
    3367 $\emph{tuple}$ = $\emph{tuple}$ = ... = $\emph{tuple}$;
     3379§\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;
    33683380\end{cfa}
    33693381and it has the same parallel semantics as for mass and multiple assignment.
    … …  
    34123424\begin{cfa}
    34133425int x = 1, y = 2, z = 3;
    3414 sout | x @|@ y @|@ z;
     3426sout | x ®|® y ®|® z;
    34153427\end{cfa}
    34163428&
    34173429\begin{cfa}
    34183430
    3419 cout << x @<< " "@ << y @<< " "@ << z << endl;
     3431cout << x ®<< " "® << y ®<< " "® << z << endl;
    34203432\end{cfa}
    34213433&
    … …  
    34263438\\
    34273439\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3428 1@ @2@ @3
     34401® ®2® ®3
    34293441\end{cfa}
    34303442&
    34313443\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3432 1@ @2@ @3
     34441® ®2® ®3
    34333445\end{cfa}
    34343446&
    34353447\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3436 1@ @2@ @3
     34481® ®2® ®3
    34373449\end{cfa}
    34383450\end{tabular}
    … …  
    34423454\begin{cfa}
    34433455[int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
    3444 sout | t1 | t2; $\C{// print tuples}$
     3456sout | t1 | t2; §\C{// print tuples}§
    34453457\end{cfa}
    34463458\begin{cfa}[showspaces=true,aboveskip=0pt]
    3447 1@, @2@, @3 4@, @5@, @6
     34591®, ®2®, ®3 4®, ®5®, ®6
    34483460\end{cfa}
    34493461Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
    … …  
    34543466&
    34553467\begin{cfa}
    3456 sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;
     3468sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
    34573469\end{cfa}
    34583470\\
    … …  
    34603472&
    34613473\begin{cfa}
    3462 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@ << endl;
     3474cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
    34633475\end{cfa}
    34643476\\
    … …  
    34953507\\
    34963508\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3497 @1@ @2.5@ @A@
     3509®1® ®2.5® ®A®
    34983510
    34993511
    … …  
    35013513&
    35023514\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3503 @1@ @2.5@ @A@
     3515®1® ®2.5® ®A®
    35043516
    35053517
    … …  
    35073519&
    35083520\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3509 @1@
    3510 @2.5@
    3511 @A@
     3521®1®
     3522®2.5®
     3523®A®
    35123524\end{cfa}
    35133525\end{tabular}
    … …  
    35453557
    35463558\item
    3547 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} a closing citation mark.
    3548 \begin{cfa}
     3559{\lstset{language=CFA,deletedelim=**[is][]{¢}{¢}}
     3560A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[basicstyle=\tt]@,.;!?)]}%¢»@, where \lstinline[basicstyle=\tt]@»@ is a closing citation mark.
     3561\begin{cfa}[belowskip=0pt]
    35493562sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
    3550            | 7 | "$\LstStringStyle{\textcent}$ x" | 8 | "$\LstStringStyle{\guillemotright}$ x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
    3551 \end{cfa}
    3552 \begin{cfa}[showspaces=true]
    3553 1@,@ x 2@.@ x 3@;@ x 4@!@ x 5@?@ x 6@%@ x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9@)@ x 10@]@ x 11@}@ x
    3554 \end{cfa}
    3555 
    3556 \item
    3557 A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{([\{=\$\textsterling\textyen\textexclamdown\textquestiondown\guillemotleft}, where \LstStringStyle{\textexclamdown\textquestiondown} are inverted opening exclamation and question marks, and \LstStringStyle{\guillemotleft} is an opening citation mark.
     3563                | 7 | "¢ x" | 8 | "» x" | 9 | ") x" | 10 | "] x" | 11 | "} x";
     3564\end{cfa}
     3565\begin{cfa}[basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
     35661®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7§\color{red}\textcent§ x 8®»® x 9®)® x 10®]® x 11®}® x
     3567\end{cfa}}%
     3568
     3569\item
     3570A separator does not appear after a C string ending with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$£¥¡¿«@, where \lstinline[basicstyle=\tt]@¡¿@ are inverted opening exclamation and question marks, and \lstinline[basicstyle=\tt]@«@ is an opening citation mark.
    35583571%$
    3559 \begin{cfa}
    3560 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
    3561            | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
     3572\begin{cfa}[mathescape=off]
     3573sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x £" | 6 | "x ¥"
     3574                | 7 | "x ¡" | 8 | "x ¿" | 9 | "x «" | 10;
    35623575\end{cfa}
    35633576%$
    3564 \begin{cfa}[showspaces=true]
    3565 x @(@1 x @[@2 x @{@3 x @=@4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
     3577\begin{cfa}[mathescape=off,basicstyle=\tt,showspaces=true,aboveskip=0pt,belowskip=0pt]
     3578x ®(®1 x ®[®2 x ®{®3 x ®=®4 x ®$®5 x ®£®6 x ®¥®7 x ®¡®8 x ®¿®9 x ®«®10
    35663579\end{cfa}
    35673580%$
    35683581
    35693582\item
    3570 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
    3571 \begin{cfa}
     3583A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
     3584\begin{cfa}[belowskip=0pt]
    35723585sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
    35733586\end{cfa}
    3574 \begin{cfa}[showspaces=true,showtabs=true]
    3575 x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@  @6@     @x
     3587\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
     3588x®`®1®`®x§\color{red}\texttt{'}§2§\color{red}\texttt{'}§x§\color{red}\texttt{"}§3§\color{red}\texttt{"}§x®:®4®:®x® ®5® ®x®      ®6®     ®x
    35763589\end{cfa}
    35773590
    35783591\item
    35793592If a space is desired before or after one of the special string start/end characters, simply insert a space.
    3580 \begin{cfa}
    3581 sout | "x ($\R{\texttt{\textvisiblespace}}$" | 1 | "$\R{\texttt{\textvisiblespace}}$) x" | 2 | "$\R{\texttt{\textvisiblespace}}$, x" | 3 | "$\R{\texttt{\textvisiblespace}}$:x:$\R{\texttt{\textvisiblespace}}$" | 4;
    3582 \end{cfa}
    3583 \begin{cfa}[showspaces=true,showtabs=true]
    3584 x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4
     3593\begin{cfa}[belowskip=0pt]
     3594sout | "x (§\color{red}\texttt{\textvisiblespace}§" | 1 | "§\color{red}\texttt{\textvisiblespace}§) x" | 2 | "§\color{red}\texttt{\textvisiblespace}§, x" | 3 | "§\color{red}\texttt{\textvisiblespace}§:x:§\color{red}\texttt{\textvisiblespace}§" | 4;
     3595\end{cfa}
     3596\begin{cfa}[basicstyle=\tt,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
     3597x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
    35853598\end{cfa}
    35863599\end{enumerate}
    … …  
    35953608\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.
    35963609The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    3597 \begin{cfa}[escapechar=off,belowskip=0pt]
    3598 sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$
    3599 sout | 1 | 2 | 3 | " \"" | @sep@ | "\"";
     3610\begin{cfa}[mathescape=off,belowskip=0pt]
     3611sepSet( sout, ", $" ); §\C{// set separator from " " to ", \$"}§
     3612sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
    36003613\end{cfa}
    36013614%$
    36023615\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
    3603 1@, $@2@, $@3 @", $"@
     36161®, $®2®, $®3 ®", $"®
    36043617\end{cfa}
    36053618%$
    36063619\begin{cfa}[belowskip=0pt]
    3607 sepSet( sout, " " ); $\C{// reset separator to " "}$
    3608 sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@ | "\"";
     3620sepSet( sout, " " ); §\C{// reset separator to " "}§
     3621sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
    36093622\end{cfa}
    36103623\begin{cfa}[showspaces=true,aboveskip=0pt]
    3611 1@ @2@ @3 @" "@
     36241® ®2® ®3 ®" "®
    36123625\end{cfa}
    36133626©sepGet© can be used to store a separator and then restore it:
    36143627\begin{cfa}[belowskip=0pt]
    3615 char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$
    3616 strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
    3617 sepSet( sout, "_" ); $\C{// change separator to underscore}$
     3628char store[®sepSize®]; §\C{// sepSize is the maximum separator size}§
     3629strcpy( store, sepGet( sout ) ); §\C{// copy current separator}§
     3630sepSet( sout, "_" ); §\C{// change separator to underscore}§
    36183631sout | 1 | 2 | 3;
    36193632\end{cfa}
    36203633\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3621 1@_@2@_@3
     36341®_®2®_®3
    36223635\end{cfa}
    36233636\begin{cfa}[belowskip=0pt]
    3624 sepSet( sout, store ); $\C{// change separator back to original}$
     3637sepSet( sout, store ); §\C{// change separator back to original}§
    36253638sout | 1 | 2 | 3;
    36263639\end{cfa}
    36273640\begin{cfa}[showspaces=true,aboveskip=0pt]
    3628 1@ @2@ @3
     36411® ®2® ®3
    36293642\end{cfa}
    36303643
    … …  
    36333646The tuple separator-string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
    36343647\begin{cfa}[belowskip=0pt]
    3635 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
    3636 sout | t1 | t2 | " \"" | @sepTuple@ | "\"";
     3648sepSetTuple( sout, " " ); §\C{// set tuple separator from ", " to " "}§
     3649sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
    36373650\end{cfa}
    36383651\begin{cfa}[showspaces=true,aboveskip=0pt]
    3639 1 2 3 4 5 6 @" "@
     36521 2 3 4 5 6 ®" "®
    36403653\end{cfa}
    36413654\begin{cfa}[belowskip=0pt]
    3642 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
    3643 sout | t1 | t2 | " \"" | @sepGetTuple( sout )@ | "\"";
     3655sepSetTuple( sout, ", " ); §\C{// reset tuple separator to ", "}§
     3656sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
    36443657\end{cfa}
    36453658\begin{cfa}[showspaces=true,aboveskip=0pt]
    3646 1, 2, 3 4, 5, 6 @", "@
     36591, 2, 3 4, 5, 6 ®", "®
    36473660\end{cfa}
    36483661As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
    … …  
    36513664\Indexc{sepDisable}\index{manipulator!sepDisable@©sepDisable©} and \Indexc{sepEnable}\index{manipulator!sepEnable@©sepEnable©} toggle printing the separator.
    36523665\begin{cfa}[belowskip=0pt]
    3653 sout | sepDisable | 1 | 2 | 3; $\C{// turn off implicit separator}$
     3666sout | sepDisable | 1 | 2 | 3; §\C{// turn off implicit separator}§
    36543667\end{cfa}
    36553668\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36573670\end{cfa}
    36583671\begin{cfa}[belowskip=0pt]
    3659 sout | sepEnable | 1 | 2 | 3; $\C{// turn on implicit separator}$
     3672sout | sepEnable | 1 | 2 | 3; §\C{// turn on implicit separator}§
    36603673\end{cfa}
    36613674\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36663679\Indexc{sepOn}\index{manipulator!sepOn@©sepOn©} and \Indexc{sepOff}\index{manipulator!sepOff@©sepOff©} toggle printing the separator with respect to the next printed item, and then return to the global seperator setting.
    36673680\begin{cfa}[belowskip=0pt]
    3668 sout | 1 | sepOff | 2 | 3; $\C{// turn off implicit separator for the next item}$
     3681sout | 1 | sepOff | 2 | 3; §\C{// turn off implicit separator for the next item}§
    36693682\end{cfa}
    36703683\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36723685\end{cfa}
    36733686\begin{cfa}[belowskip=0pt]
    3674 sout | sepDisable | 1 | sepOn | 2 | 3; $\C{// turn on implicit separator for the next item}$
     3687sout | sepDisable | 1 | sepOn | 2 | 3; §\C{// turn on implicit separator for the next item}§
    36753688\end{cfa}
    36763689\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36793692The tuple separator also responses to being turned on and off.
    36803693\begin{cfa}[belowskip=0pt]
    3681 sout | t1 | sepOff | t2; $\C{// turn off implicit separator for the next item}$
     3694sout | t1 | sepOff | t2; §\C{// turn off implicit separator for the next item}§
    36823695\end{cfa}
    36833696\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36873700use ©sep© to accomplish this functionality.
    36883701\begin{cfa}[belowskip=0pt]
    3689 sout | sepOn | 1 | 2 | 3 | sepOn; $\C{// sepOn does nothing at start/end of line}$
     3702sout | sepOn | 1 | 2 | 3 | sepOn; §\C{// sepOn does nothing at start/end of line}§
    36903703\end{cfa}
    36913704\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    … …  
    36933706\end{cfa}
    36943707\begin{cfa}[belowskip=0pt]
    3695 sout | sep | 1 | 2 | 3 | sep ; $\C{// use sep to print separator at start/end of line}$
     3708sout | sep | 1 | 2 | 3 | sep ; §\C{// use sep to print separator at start/end of line}§
    36963709\end{cfa}
    36973710\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3698 @ @1 2 3@ @
     3711® ®1 2 3® ®
    36993712\end{cfa}
    37003713\end{enumerate}
    … …  
    37083721\begin{enumerate}[parsep=0pt]
    37093722\item
    3710 \Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, \ie ignore the remaining characters in the line.
     3723\Indexc{nl}\index{manipulator!nl@©nl©} scans characters until the next newline character, i.e., ignore the remaining characters in the line.
    37113724\item
    37123725\Indexc{nlOn}\index{manipulator!nlOn@©nlOn©} reads the newline character, when reading single characters.
    … …  
    37163729For example, in:
    37173730\begin{cfa}
    3718 sin | i | @nl@ | j;
    3719 1 @2@
     3731sin | i | ®nl® | j;
     37321 ®2®
    372037333
    37213734\end{cfa}
    … …  
    37273740\Indexc{nl}\index{manipulator!nl@©nl©} inserts a newline.
    37283741\begin{cfa}
    3729 sout | nl; $\C{// only print newline}$
    3730 sout | 2; $\C{// implicit newline}$
    3731 sout | 3 | nl | 4 | nl; $\C{// terminating nl merged with implicit newline}$
    3732 sout | 5 | nl | nl; $\C{// again terminating nl merged with implicit newline}$
    3733 sout | 6; $\C{// implicit newline}$
     3742sout | nl; §\C{// only print newline}§
     3743sout | 2; §\C{// implicit newline}§
     3744sout | 3 | nl | 4 | nl; §\C{// terminating nl merged with implicit newline}§
     3745sout | 5 | nl | nl; §\C{// again terminating nl merged with implicit newline}§
     3746sout | 6; §\C{// implicit newline}§
    37343747
    373537482
    … …  
    375837710b0 0b11011 0b11011 0b11011 0b11011
    37593772sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
    3760 0b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101
     37730b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101
    37613774\end{cfa}
    37623775
    … …  
    37973810\begin{cfa}[belowskip=0pt]
    37983811sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
    3799 0@B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+4
     38120®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
    38003813\end{cfa}
    38013814
    … …  
    38133826\begin{cfa}[belowskip=0pt]
    38143827sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
    3815 0.0 @0@ 27.0 @27@ 27.5
     38280.0 ®0® 27.0 ®27® 27.5
    38163829\end{cfa}
    38173830
    … …  
    38203833\begin{cfa}[belowskip=0pt]
    38213834sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
    3822 @+@27 -27 @+@27.0 -27.0 @+@27.5 -27.5
     3835®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
    38233836\end{cfa}
    38243837
    … …  
    38333846\end{cfa}
    38343847\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3835 @  @34 @ @34 34
    3836 @  @4.000000 @ @4.000000 4.000000
    3837 @  @ab @ @ab ab
     3848®  ®34 ® ®34 34
     3849®  ®4.000000 ® ®4.000000 4.000000
     3850®  ®ab ® ®ab ab
    38383851\end{cfa}
    38393852If the value is larger, it is printed without truncation, ignoring the ©minimum©.
    … …  
    38443857\end{cfa}
    38453858\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3846 3456@7@ 345@67@ 34@567@
    3847 3456@.@ 345@6.@ 34@56.@
    3848 abcd@e@ abc@de@ ab@cde@
     38593456®7® 345®67® 34®567®
     38603456®.® 345®6.® 34®56.®
     3861abcd®e® abc®de® ab®cde®
    38493862\end{cfa}
    38503863
    … …  
    38553868\end{cfa}
    38563869\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3857  @0@34     @00@34 @00000000@34
     3870 ®0®34     ®00®34 ®00000000®34
    38583871\end{cfa}
    38593872If the value is larger, it is printed without truncation, ignoring the ©precision©.
    … …  
    38703883\end{cfa}
    38713884\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3872 @    @ @00000000@34
     3885®    ® ®00000000®34
    38733886\end{cfa}
    38743887For floating-point types, ©precision© is the minimum number of digits after the decimal point.
    … …  
    38773890\end{cfa}
    38783891\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3879 27.@500@     27.@5@      28. 27.@50000000@
    3880 \end{cfa}
    3881 For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
     389227.®500®     27.®5®      28. 27.®50000000®
     3893\end{cfa}
     3894For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncared if it exceeds the maximum.
    38823895\begin{cfa}[belowskip=0pt]
    38833896sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
    … …  
    38953908\end{cfa}
    38963909\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3897 234.567 234.5@7@  234.@6@    23@5@
     3910234.567 234.5®7®  234.®6®    23®5®
    38983911\end{cfa}
    38993912If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
    … …  
    39023915\end{cfa}
    39033916\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3904 234567. 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@
     3917234567. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
    39053918\end{cfa}
    39063919If ©significant© is greater than ©minimum©, it defines the number of printed characters.
    … …  
    39183931\end{cfa}
    39193932\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    3920 27@  @ 27.000000  27.500000  027  27.500@    @
     393327®  ® 27.000000  27.500000  027  27.500®    ®
    39213934\end{cfa}
    39223935
    … …  
    39253938\begin{cfa}[belowskip=0pt]
    39263939sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
    3927 @00@27  @0@27 @00@27.500
     3940®00®27  ®0®27 ®00®27.500
    39283941\end{cfa}
    39293942\end{enumerate}
    … …  
    40214034\end{cfa}
    40224035\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4023 @abc   @
    4024 @abc  @
    4025 @xx@
     4036®abc   ®
     4037®abc  ®
     4038®xx®
    40264039\end{cfa}
    40274040
    … …  
    40344047\end{cfa}
    40354048\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4036 @abcd1233.456E+2@
     4049®abcd1233.456E+2®
    40374050\end{cfa}
    40384051Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
    … …  
    40474060\end{cfa}
    40484061\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4049 @  -75.35e-4@ 25
     4062®  -75.35e-4® 25
    40504063\end{cfa}
    40514064
    … …  
    40594072\end{cfa}
    40604073\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4061 @bca@xyz
     4074®bca®xyz
    40624075\end{cfa}
    40634076
    … …  
    40714084\end{cfa}
    40724085\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
    4073 @xyz@bca
     4086®xyz®bca
    40744087\end{cfa}
    40754088\end{enumerate}
    … …  
    40884101
    40894102A type definition is different from a typedef in C because a typedef just creates an alias for a type,  while Do.s type definition creates a distinct type.
    4090 This means that users can define distinct function overloads for the new type \see{\VRef{s:Overloading} for more information}.
     4103This means that users can define distinct function overloads for the new type (see Overloading for more information).
    40914104For example:
    40924105
    … …  
    41944207\CFA supports C initialization of structures, but it also adds constructors for more advanced initialization.
    41954208Additionally, \CFA adds destructors that are called when a variable is deallocated (variable goes out of scope or object is deleted).
    4196 These functions take a reference to the structure as a parameter \see{\VRef{s:PointerReference} for more information}.
     4209These functions take a reference to the structure as a parameter (see References for more information).
    41974210
    41984211\begin{figure}
    … …  
    42454258
    42464259\section{Overloading}
    4247 \label{s:Overloading}
    42484260
    42494261Overloading refers to the capability of a programmer to define and use multiple objects in a program with the same name.
    … …  
    42784290
    42794291
    4280 \subsection{Constant}
     4292\subsection{Overloaded Constant}
    42814293
    42824294The constants 0 and 1 have special meaning.
    … …  
    43174329
    43184330
    4319 \subsection{Variable}
    4320 \label{s:VariableOverload}
     4331\subsection{Variable Overloading}
    43214332
    43224333The overload rules of \CFA allow a programmer to define multiple variables with the same name, but different types.
    … …  
    43614372
    43624373
    4363 \subsection{Operator}
     4374\subsection{Operator Overloading}
    43644375
    43654376\CFA also allows operators to be overloaded, to simplify the use of user-defined types.
    … …  
    44574468For example, given
    44584469\begin{cfa}
    4459 auto j = @...@
     4470auto j = ®...®
    44604471\end{cfa}
    44614472and the need to write a routine to compute using ©j©
    44624473\begin{cfa}
    4463 void rtn( @...@ parm );
     4474void rtn( ®...® parm );
    44644475rtn( j );
    44654476\end{cfa}
    … …  
    47024713
    47034714coroutine Fibonacci {
    4704         int fn; $\C{// used for communication}$
     4715        int fn; §\C{// used for communication}§
    47054716};
    47064717void ?{}( Fibonacci * this ) {
    … …  
    47084719}
    47094720void main( Fibonacci * this ) {
    4710         int fn1, fn2; $\C{// retained between resumes}$
    4711         this->fn = 0; $\C{// case 0}$
     4721        int fn1, fn2; §\C{// retained between resumes}§
     4722        this->fn = 0; §\C{// case 0}§
    47124723        fn1 = this->fn;
    4713         suspend(); $\C{// return to last resume}$
    4714 
    4715         this->fn = 1; $\C{// case 1}$
     4724        suspend(); §\C{// return to last resume}§
     4725
     4726        this->fn = 1; §\C{// case 1}§
    47164727        fn2 = fn1;
    47174728        fn1 = this->fn;
    4718         suspend(); $\C{// return to last resume}$
    4719 
    4720         for ( ;; ) { $\C{// general case}$
     4729        suspend(); §\C{// return to last resume}§
     4730
     4731        for ( ;; ) { §\C{// general case}§
    47214732                this->fn = fn1 + fn2;
    47224733                fn2 = fn1;
    47234734                fn1 = this->fn;
    4724                 suspend(); $\C{// return to last resume}$
     4735                suspend(); §\C{// return to last resume}§
    47254736        } // for
    47264737}
    47274738int next( Fibonacci * this ) {
    4728         resume( this ); $\C{// transfer to last suspend}$
     4739        resume( this ); §\C{// transfer to last suspend}§
    47294740        return this->fn;
    47304741}
    … …  
    49534964When building a \CFA module which needs to be callable from C code, users can use the tools to generate a header file suitable for including in these C files with all of the needed declarations.
    49544965
    4955 In order to interoperate with existing C code, \CFA files can still include header files, the contents of which will be enclosed in a C linkage section to indicate C calling conventions \see{\VRef{s:Interoperability} for more information}.
     4966In order to interoperate with existing C code, \CFA files can still include header files, the contents of which will be enclosed in a C linkage section to indicate C calling conventions (see Interoperability for more information).
    49564967
    49574968
    … …  
    56195630\end{cfa}
    56205631&
    5621 \begin{C++}
     5632\begin{lstlisting}[language=C++]
    56225633class Line {
    56235634        float lnth;
    … …  
    56465657Line line1;
    56475658Line line2( 3.4 );
    5648 \end{C++}
     5659\end{lstlisting}
    56495660&
    56505661\begin{lstlisting}[language=Golang]
    … …  
    62716282In \CFA, there are ambiguous cases with dereference and operator identifiers, \eg ©int *?*?()©, where the string ©*?*?© can be interpreted as:
    62726283\begin{cfa}
    6273 *?$\R{\textvisiblespace}$*? $\C{// dereference operator, dereference operator}$
    6274 *$\R{\textvisiblespace}$?*? $\C{// dereference, multiplication operator}$
     6284*?§\color{red}\textvisiblespace§*? §\C{// dereference operator, dereference operator}§
     6285*§\color{red}\textvisiblespace§?*? §\C{// dereference, multiplication operator}§
    62756286\end{cfa}
    62766287By default, the first interpretation is selected, which does not yield a meaningful parse.
    … …  
    62816292The ambiguity occurs when the deference operator has no parameters:
    62826293\begin{cfa}
    6283 *?()$\R{\textvisiblespace...}$ ;
    6284 *?()$\R{\textvisiblespace...}$(...) ;
     6294*?()§\color{red}\textvisiblespace...§ ;
     6295*?()§\color{red}\textvisiblespace...§(...) ;
    62856296\end{cfa}
    62866297requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
    … …  
    62906301The remaining cases are with the increment/decrement operators and conditional expression, \eg:
    62916302\begin{cfa}
    6292 i++?$\R{\textvisiblespace...}$(...);
    6293 i?++$\R{\textvisiblespace...}$(...);
     6303i++?§\color{red}\textvisiblespace...§(...);
     6304i?++§\color{red}\textvisiblespace...§(...);
    62946305\end{cfa}
    62956306requiring arbitrary whitespace look-ahead for the operator parameter-list, even though that interpretation is an incorrect expression (juxtaposed identifiers).
    62966307Therefore, it is necessary to disambiguate these cases with a space:
    62976308\begin{cfa}
    6298 i++$\R{\textvisiblespace}$? i : 0;
    6299 i?$\R{\textvisiblespace}$++i : 0;
     6309i++§\color{red}\textvisiblespace§? i : 0;
     6310i?§\color{red}\textvisiblespace§++i : 0;
    63006311\end{cfa}
    63016312
    … …  
    63106321\begin{description}
    63116322\item[Change:] add new keywords \\
    6312 New keywords are added to \CFA \see{\VRef{s:CFAKeywords}}.
     6323New keywords are added to \CFA (see~\VRef{s:CFAKeywords}).
    63136324\item[Rationale:] keywords added to implement new semantics of \CFA.
    63146325\item[Effect on original feature:] change to semantics of well-defined feature. \\
    63156326Any \Celeven programs using these keywords as identifiers are invalid \CFA programs.
    6316 \item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism \see{\VRef{s:BackquoteIdentifiers}}.
     6327\item[Difficulty of converting:] keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism (see~\VRef{s:BackquoteIdentifiers}).
    63176328\item[How widely used:] clashes among new \CFA keywords and existing identifiers are rare.
    63186329\end{description}
    … …  
    63246335\eg:
    63256336\begin{cfa}
    6326 x; $\C{// int x}$
    6327 *y; $\C{// int *y}$
    6328 f( p1, p2 ); $\C{// int f( int p1, int p2 );}$
    6329 g( p1, p2 ) int p1, p2; $\C{// int g( int p1, int p2 );}$
     6337x; §\C{// int x}§
     6338*y; §\C{// int *y}§
     6339f( p1, p2 ); §\C{// int f( int p1, int p2 );}§
     6340g( p1, p2 ) int p1, p2; §\C{// int g( int p1, int p2 );}§
    63306341\end{cfa}
    63316342\CFA continues to support K\&R routine definitions:
    63326343\begin{cfa}
    6333 f( a, b, c ) $\C{// default int return}$
    6334         int a, b; char c $\C{// K\&R parameter declarations}$
     6344f( a, b, c ) §\C{// default int return}§
     6345        int a, b; char c §\C{// K\&R parameter declarations}§
    63356346{
    63366347        ...
    … …  
    63516362int rtn( int i );
    63526363int rtn( char c );
    6353 rtn( 'x' ); $\C{// programmer expects 2nd rtn to be called}$
     6364rtn( 'x' ); §\C{// programmer expects 2nd rtn to be called}§
    63546365\end{cfa}
    63556366\item[Rationale:] it is more intuitive for the call to ©rtn© to match the second version of definition of ©rtn© rather than the first.
    … …  
    63736384\item[Change:] make string literals ©const©:
    63746385\begin{cfa}
    6375 char * p = "abc"; $\C{// valid in C, deprecated in \CFA}$
    6376 char * q = expr ? "abc" : "de"; $\C{// valid in C, invalid in \CFA}$
     6386char * p = "abc"; §\C{// valid in C, deprecated in \CFA}§
     6387char * q = expr ? "abc" : "de"; §\C{// valid in C, invalid in \CFA}§
    63776388\end{cfa}
    63786389The type of a string literal is changed from ©[] char© to ©const [] char©.
    … …  
    63816392\begin{cfa}
    63826393char * p = "abc";
    6383 p[0] = 'w'; $\C{// segment fault or change constant literal}$
     6394p[0] = 'w'; §\C{// segment fault or change constant literal}§
    63846395\end{cfa}
    63856396The same problem occurs when passing a string literal to a routine that changes its argument.
    … …  
    63936404\item[Change:] remove \newterm{tentative definitions}, which only occurs at file scope:
    63946405\begin{cfa}
    6395 int i; $\C{// forward definition}$
    6396 int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$
    6397 int i = 0; $\C{// definition}$
     6406int i; §\C{// forward definition}§
     6407int *j = ®&i®; §\C{// forward reference, valid in C, invalid in \CFA}§
     6408int i = 0; §\C{// definition}§
    63986409\end{cfa}
    63996410is valid in C, and invalid in \CFA because duplicate overloaded object definitions at the same scope level are disallowed.
    … …  
    64016412\begin{cfa}
    64026413struct X { int i; struct X *next; };
    6403 static struct X a; $\C{// forward definition}$
    6404 static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$
    6405 static struct X a = { 1, &b }; $\C{// definition}$
     6414static struct X a; §\C{// forward definition}§
     6415static struct X b = { 0, ®&a® };§\C{// forward reference, valid in C, invalid in \CFA}§
     6416static struct X a = { 1, &b }; §\C{// definition}§
    64066417\end{cfa}
    64076418\item[Rationale:] avoids having different initialization rules for builtin types and user-defined types.
    … …  
    64156426\item[Change:] have ©struct© introduce a scope for nested types:
    64166427\begin{cfa}
    6417 enum @Colour@ { R, G, B, Y, C, M };
     6428enum ®Colour® { R, G, B, Y, C, M };
    64186429struct Person {
    6419         enum @Colour@ { R, G, B };      $\C[7cm]{// nested type}$
    6420         struct Face { $\C{// nested type}$
    6421                 @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$
     6430        enum ®Colour® { R, G, B };      §\C[7cm]{// nested type}§
     6431        struct Face { §\C{// nested type}§
     6432                ®Colour® Eyes, Hair; §\C{// type defined outside (1 level)}§
    64226433        };
    6423         @.Colour@ shirt; $\C{// type defined outside (top level)}$
    6424         @Colour@ pants; $\C{// type defined same level}$
    6425         Face looks[10]; $\C{// type defined same level}$
     6434        ®.Colour® shirt; §\C{// type defined outside (top level)}§
     6435        ®Colour® pants; §\C{// type defined same level}§
     6436        Face looks[10]; §\C{// type defined same level}§
    64266437};
    6427 @Colour@ c = R; $\C{// type/enum defined same level}$
    6428 Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$
    6429 Person@.@Face pretty; $\C{// type defined inside}\CRT$
     6438®Colour® c = R; §\C{// type/enum defined same level}§
     6439Person®.Colour® pc = Person®.®R;§\C{// type/enum defined inside}§
     6440Person®.®Face pretty; §\C{// type defined inside}\CRT§
    64306441\end{cfa}
    64316442In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
    … …  
    64446455\item[Difficulty of converting:] Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
    64456456\begin{cfa}
    6446 struct Y; $\C{// struct Y and struct X are at the same scope}$
     6457struct Y; §\C{// struct Y and struct X are at the same scope}§
    64476458struct X {
    64486459        struct Y { /* ... */ } y;
    … …  
    64596470\begin{cfa}
    64606471void foo() {
    6461         int * b = malloc( sizeof(int) ); $\C{// implicitly convert void * to int *}$
    6462         char * c = b; $\C{// implicitly convert int * to void *, and then void * to char *}$
     6472        int * b = malloc( sizeof(int) ); §\C{// implicitly convert void * to int *}§
     6473        char * c = b; §\C{// implicitly convert int * to void *, and then void * to char *}§
    64636474}
    64646475\end{cfa}
    64656476\item[Rationale:] increase type safety
    64666477\item[Effect on original feature:] deletion of semantically well-defined feature.
    6467 \item[Difficulty of converting:] requires adding a cast \see{\VRef{s:StorageManagement} for better alternatives}:
     6478\item[Difficulty of converting:] requires adding a cast (see \VRef{s:StorageManagement} for better alternatives):
    64686479\begin{cfa}
    64696480        int * b = (int *)malloc( sizeof(int) );
    … …  
    65756586\end{cquote}
    65766587For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
    6577 hence, names in these include files are not mangled\index{mangling!name} \see{\VRef{s:Interoperability}}.
     6588hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
    65786589All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling.
    65796590This approach is different from \Index*[C++]{\CC{}} where the name-mangling issue is handled internally in C header-files through checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers.
    … …  
    66386649Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in
    66396650\begin{cfa}
    6640 int * ip = (int *)malloc( sizeof(int) );                $\C{// C}$
    6641 int * ip = malloc();                                                    $\C{// \CFA type-safe version of C malloc}$
    6642 int * ip = alloc();                                                             $\C{// \CFA type-safe uniform alloc}$
     6651int * ip = (int *)malloc( sizeof(int) );                §\C{// C}§
     6652int * ip = malloc();                                                    §\C{// \CFA type-safe version of C malloc}§
     6653int * ip = alloc();                                                             §\C{// \CFA type-safe uniform alloc}§
    66436654\end{cfa}
    66446655the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©.
    … …  
    66476658\begin{cfa}
    66486659struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment
    6649 S * sp = malloc();                                                              $\C{// honour type alignment}$
     6660S * sp = malloc();                                                              §\C{// honour type alignment}§
    66506661\end{cfa}
    66516662the storage allocation is implicitly aligned to 128 rather than the default 16.
    … …  
    66626673\CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
    66636674\begin{cfa}
    6664 struct S { int i; };                                                    $\C{// cache-line alignment}$
     6675struct S { int i; };                                                    §\C{// cache-line aglinment}§
    66656676void ?{}( S & s, int i ) { s.i = i; }
    66666677// assume ?|? operator for printing an S
    66676678
    6668 S & sp = *@new@( 3 );                                                   $\C{// call constructor after allocation}$
     6679S & sp = *®new®( 3 );                                                   §\C{// call constructor after allocation}§
    66696680sout | sp.i;
    6670 @delete@( &sp );
    6671 
    6672 S * spa = @anew@( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
     6681®delete®( &sp );
     6682
     6683S * spa = ®anew®( 10, 5 );                                              §\C{// allocate array and initialize each array element}§
    66736684for ( i; 10 ) sout | spa[i] | nonl;
    66746685sout | nl;
    6675 @adelete@( 10, spa );
     6686®adelete®( 10, spa );
    66766687\end{cfa}
    66776688Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
    … …  
    66826693extern "C" {
    66836694        // C unsafe allocation
    6684         void * malloc( size_t size );$\indexc{malloc}$
    6685         void * calloc( size_t dim, size_t size );$\indexc{calloc}$
    6686         void * realloc( void * ptr, size_t size );$\indexc{realloc}$
    6687         void * memalign( size_t align, size_t size );$\indexc{memalign}$
    6688         void * aligned_alloc( size_t align, size_t size );$\indexc{aligned_alloc}$
    6689         int posix_memalign( void ** ptr, size_t align, size_t size );$\indexc{posix_memalign}$
    6690         void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );$\indexc{cmemalign}$ // CFA
     6695        void * malloc( size_t size );§\indexc{malloc}§
     6696        void * calloc( size_t dim, size_t size );§\indexc{calloc}§
     6697        void * realloc( void * ptr, size_t size );§\indexc{realloc}§
     6698        void * memalign( size_t align, size_t size );§\indexc{memalign}§
     6699        void * aligned_alloc( size_t align, size_t size );§\indexc{aligned_alloc}§
     6700        int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
     6701        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );§\indexc{cmemalign}§ // CFA
    66916702
    66926703        // C unsafe initialization/copy
    6693         void * memset( void * dest, int c, size_t size );$\indexc{memset}$
    6694         void * memcpy( void * dest, const void * src, size_t size );$\indexc{memcpy}$
     6704        void * memset( void * dest, int c, size_t size );§\indexc{memset}§
     6705        void * memcpy( void * dest, const void * src, size_t size );§\indexc{memcpy}§
    66956706}
    66966707
    … …  
    66986709
    66996710forall( dtype T | sized(T) ) {
    6700         // $\CFA$ safe equivalents, i.e., implicit size specification
     6711        // §\CFA§ safe equivalents, i.e., implicit size specification
    67016712        T * malloc( void );
    67026713        T * calloc( size_t dim );
    … …  
    67076718        int posix_memalign( T ** ptr, size_t align );
    67086719
    6709         // $\CFA$ safe general allocation, fill, resize, alignment, array
    6710         T * alloc( void );$\indexc{alloc}$                                      $\C[3.5in]{// variable, T size}$
    6711         T * alloc( size_t dim );                                                        $\C{// array[dim], T size elements}$
    6712         T * alloc( T ptr[], size_t dim );                                       $\C{// realloc array[dim], T size elements}$
    6713 
    6714         T * alloc_set( char fill );$\indexc{alloc_set}$         $\C{// variable, T size, fill bytes with value}$
    6715         T * alloc_set( T fill );                                                        $\C{// variable, T size, fill with value}$
    6716         T * alloc_set( size_t dim, char fill );                         $\C{// array[dim], T size elements, fill bytes with value}$
    6717         T * alloc_set( size_t dim, T fill );                            $\C{// array[dim], T size elements, fill elements with value}$
    6718         T * alloc_set( size_t dim, const T fill[] );            $\C{// array[dim], T size elements, fill elements with array}$
    6719         T * alloc_set( T ptr[], size_t dim, char fill );        $\C{// realloc array[dim], T size elements, fill bytes with value}$
    6720 
    6721         T * alloc_align( size_t align );                                        $\C{// aligned variable, T size}$
    6722         T * alloc_align( size_t align, size_t dim );            $\C{// aligned array[dim], T size elements}$
    6723         T * alloc_align( T ptr[], size_t align );                       $\C{// realloc new aligned array}$
    6724         T * alloc_align( T ptr[], size_t align, size_t dim ); $\C{// realloc new aligned array[dim]}$
    6725 
    6726         T * alloc_align_set( size_t align, char fill );         $\C{// aligned variable, T size, fill bytes with value}$
    6727         T * alloc_align_set( size_t align, T fill );            $\C{// aligned variable, T size, fill with value}$
    6728         T * alloc_align_set( size_t align, size_t dim, char fill ); $\C{// aligned array[dim], T size elements, fill bytes with value}$
    6729         T * alloc_align_set( size_t align, size_t dim, T fill ); $\C{// aligned array[dim], T size elements, fill elements with value}$
    6730         T * alloc_align_set( size_t align, size_t dim, const T fill[] ); $\C{// aligned array[dim], T size elements, fill elements with array}$
    6731         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); $\C{// realloc new aligned array[dim], fill new bytes with value}$
    6732 
    6733         // $\CFA$ safe initialization/copy, i.e., implicit size specification
    6734         T * memset( T * dest, char fill );$\indexc{memset}$
    6735         T * memcpy( T * dest, const T * src );$\indexc{memcpy}$
    6736 
    6737         // $\CFA$ safe initialization/copy, i.e., implicit size specification, array types
     6720        // §\CFA§ safe general allocation, fill, resize, alignment, array
     6721        T * alloc( void );§\indexc{alloc}§                                      §\C[3.5in]{// variable, T size}§
     6722        T * alloc( size_t dim );                                                        §\C{// array[dim], T size elements}§
     6723        T * alloc( T ptr[], size_t dim );                                       §\C{// realloc array[dim], T size elements}§
     6724
     6725        T * alloc_set( char fill );§\indexc{alloc_set}§         §\C{// variable, T size, fill bytes with value}§
     6726        T * alloc_set( T fill );                                                        §\C{// variable, T size, fill with value}§
     6727        T * alloc_set( size_t dim, char fill );                         §\C{// array[dim], T size elements, fill bytes with value}§
     6728        T * alloc_set( size_t dim, T fill );                            §\C{// array[dim], T size elements, fill elements with value}§
     6729        T * alloc_set( size_t dim, const T fill[] );            §\C{// array[dim], T size elements, fill elements with array}§
     6730        T * alloc_set( T ptr[], size_t dim, char fill );        §\C{// realloc array[dim], T size elements, fill bytes with value}§
     6731
     6732        T * alloc_align( size_t align );                                        §\C{// aligned variable, T size}§
     6733        T * alloc_align( size_t align, size_t dim );            §\C{// aligned array[dim], T size elements}§
     6734        T * alloc_align( T ptr[], size_t align );                       §\C{// realloc new aligned array}§
     6735        T * alloc_align( T ptr[], size_t align, size_t dim ); §\C{// realloc new aligned array[dim]}§
     6736
     6737        T * alloc_align_set( size_t align, char fill );         §\C{// aligned variable, T size, fill bytes with value}§
     6738        T * alloc_align_set( size_t align, T fill );            §\C{// aligned variable, T size, fill with value}§
     6739        T * alloc_align_set( size_t align, size_t dim, char fill ); §\C{// aligned array[dim], T size elements, fill bytes with value}§
     6740        T * alloc_align_set( size_t align, size_t dim, T fill ); §\C{// aligned array[dim], T size elements, fill elements with value}§
     6741        T * alloc_align_set( size_t align, size_t dim, const T fill[] ); §\C{// aligned array[dim], T size elements, fill elements with array}§
     6742        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§
     6743
     6744        // §\CFA§ safe initialization/copy, i.e., implicit size specification
     6745        T * memset( T * dest, char fill );§\indexc{memset}§
     6746        T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
     6747
     6748        // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types
    67386749        T * amemset( T dest[], char fill, size_t dim );
    67396750        T * amemcpy( T dest[], const T src[], size_t dim );
    67406751}
    67416752
    6742 // $\CFA$ allocation/deallocation and constructor/destructor, non-array types
    6743 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );$\indexc{new}$
    6744 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );$\indexc{delete}$
     6753// §\CFA§ allocation/deallocation and constructor/destructor, non-array types
     6754forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );§\indexc{new}§
     6755forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );§\indexc{delete}§
    67456756forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
    67466757  void delete( T * ptr, Params rest );
    67476758
    6748 // $\CFA$ allocation/deallocation and constructor/destructor, array types
    6749 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );$\indexc{anew}$
    6750 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );$\indexc{adelete}$
     6759// §\CFA§ allocation/deallocation and constructor/destructor, array types
     6760forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
     6761forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
    67516762forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
    67526763  void adelete( size_t dim, T arr[], Params rest );
    … …  
    67586769\leavevmode
    67596770\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6760 int ato( const char * ptr );$\indexc{ato}$
     6771int ato( const char * ptr );§\indexc{ato}§
    67616772unsigned int ato( const char * ptr );
    67626773long int ato( const char * ptr );
    … …  
    67906801\leavevmode
    67916802\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6792 forall( otype T | { int ?<?( T, T ); } ) $\C{// location}$
    6793 T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$
    6794 
    6795 forall( otype T | { int ?<?( T, T ); } ) $\C{// position}$
     6803forall( otype T | { int ?<?( T, T ); } ) §\C{// location}§
     6804T * bsearch( T key, const T * arr, size_t dim );§\indexc{bsearch}§
     6805
     6806forall( otype T | { int ?<?( T, T ); } ) §\C{// position}§
    67966807unsigned int bsearch( T key, const T * arr, size_t dim );
    67976808
    67986809forall( otype T | { int ?<?( T, T ); } )
    6799 void qsort( const T * arr, size_t dim );$\indexc{qsort}$
     6810void qsort( const T * arr, size_t dim );§\indexc{qsort}§
    68006811
    68016812forall( otype E | { int ?<?( E, E ); } ) {
    6802         E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ $\C{// location}$
    6803         size_t bsearch( E key, const E * vals, size_t dim );$\C{// position}$
    6804         E * bsearchl( E key, const E * vals, size_t dim );$\indexc{bsearchl}$
     6813        E * bsearch( E key, const E * vals, size_t dim );§\indexc{bsearch}§ §\C{// location}§
     6814        size_t bsearch( E key, const E * vals, size_t dim );§\C{// position}§
     6815        E * bsearchl( E key, const E * vals, size_t dim );§\indexc{bsearchl}§
    68056816        size_t bsearchl( E key, const E * vals, size_t dim );
    6806         E * bsearchu( E key, const E * vals, size_t dim );$\indexc{bsearchu}$
     6817        E * bsearchu( E key, const E * vals, size_t dim );§\indexc{bsearchu}§
    68076818        size_t bsearchu( E key, const E * vals, size_t dim );
    68086819}
    … …  
    68186829
    68196830forall( otype E | { int ?<?( E, E ); } ) {
    6820         void qsort( E * vals, size_t dim );$\indexc{qsort}$
     6831        void qsort( E * vals, size_t dim );§\indexc{qsort}§
    68216832}
    68226833\end{cfa}
    … …  
    68276838\leavevmode
    68286839\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6829 unsigned char abs( signed char );$\indexc{abs}$
     6840unsigned char abs( signed char );§\indexc{abs}§
    68306841int abs( int );
    68316842unsigned long int abs( long int );
    … …  
    68466857\leavevmode
    68476858\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6848 void srandom( unsigned int seed );$\indexc{srandom}$
    6849 char random( void );$\indexc{random}$
    6850 char random( char u ); $\C{// [0,u)}$
    6851 char random( char l, char u ); $\C{// [l,u)}$
     6859void srandom( unsigned int seed );§\indexc{srandom}§
     6860char random( void );§\indexc{random}§
     6861char random( char u ); §\C{// [0,u)}§
     6862char random( char l, char u ); §\C{// [l,u)}§
    68526863int random( void );
    6853 int random( int u ); $\C{// [0,u)}$
    6854 int random( int l, int u ); $\C{// [l,u)}$
     6864int random( int u ); §\C{// [0,u)}§
     6865int random( int l, int u ); §\C{// [l,u)}§
    68556866unsigned int random( void );
    6856 unsigned int random( unsigned int u ); $\C{// [0,u)}$
    6857 unsigned int random( unsigned int l, unsigned int u ); $\C{// [l,u)}$
     6867unsigned int random( unsigned int u ); §\C{// [0,u)}§
     6868unsigned int random( unsigned int l, unsigned int u ); §\C{// [l,u)}§
    68586869long int random( void );
    6859 long int random( long int u ); $\C{// [0,u)}$
    6860 long int random( long int l, long int u ); $\C{// [l,u)}$
     6870long int random( long int u ); §\C{// [0,u)}§
     6871long int random( long int l, long int u ); §\C{// [l,u)}§
    68616872unsigned long int random( void );
    6862 unsigned long int random( unsigned long int u ); $\C{// [0,u)}$
    6863 unsigned long int random( unsigned long int l, unsigned long int u ); $\C{// [l,u)}$
    6864 float random( void );                                            $\C{// [0.0, 1.0)}$
    6865 double random( void );                                           $\C{// [0.0, 1.0)}$
    6866 float _Complex random( void );                           $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
    6867 double _Complex random( void );                          $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
    6868 long double _Complex random( void );             $\C{// [0.0, 1.0)+[0.0, 1.0)i}$
     6873unsigned long int random( unsigned long int u ); §\C{// [0,u)}§
     6874unsigned long int random( unsigned long int l, unsigned long int u ); §\C{// [l,u)}§
     6875float random( void );                                            §\C{// [0.0, 1.0)}§
     6876double random( void );                                           §\C{// [0.0, 1.0)}§
     6877float _Complex random( void );                           §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
     6878double _Complex random( void );                          §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
     6879long double _Complex random( void );             §\C{// [0.0, 1.0)+[0.0, 1.0)i}§
    68696880\end{cfa}
    68706881
    … …  
    68746885\leavevmode
    68756886\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6876 forall( otype T | { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$
    6877 forall( otype T | { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$
    6878 forall( otype T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$
    6879 forall( otype T ) void swap( T * t1, T * t2 );$\indexc{swap}$
     6887forall( otype T | { int ?<?( T, T ); } ) T min( T t1, T t2 );§\indexc{min}§
     6888forall( otype T | { int ?>?( T, T ); } ) T max( T t1, T t2 );§\indexc{max}§
     6889forall( otype T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );§\indexc{clamp}§
     6890forall( otype T ) void swap( T * t1, T * t2 );§\indexc{swap}§
    68806891\end{cfa}
    68816892
    … …  
    68916902\leavevmode
    68926903\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6893 float ?%?( float, float );$\indexc{fmod}$
     6904float ?%?( float, float );§\indexc{fmod}§
    68946905float fmod( float, float );
    68956906double ?%?( double, double );
    … …  
    68986909long double fmod( long double, long double );
    68996910
    6900 float remainder( float, float );$\indexc{remainder}$
     6911float remainder( float, float );§\indexc{remainder}§
    69016912double remainder( double, double );
    69026913long double remainder( long double, long double );
    69036914
    6904 float remquo( float, float, int * );$\indexc{remquo}$
     6915float remquo( float, float, int * );§\indexc{remquo}§
    69056916double remquo( double, double, int * );
    69066917long double remquo( long double, long double, int * );
    … …  
    69096920[ int, long double ] remquo( long double, long double );
    69106921
    6911 float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
     6922float div( float, float, int * );§\indexc{div}§ §\C{// alternative name for remquo}§
    69126923double div( double, double, int * );
    69136924long double div( long double, long double, int * );
    … …  
    69166927[ int, long double ] div( long double, long double );
    69176928
    6918 float fma( float, float, float );$\indexc{fma}$
     6929float fma( float, float, float );§\indexc{fma}§
    69196930double fma( double, double, double );
    69206931long double fma( long double, long double, long double );
    69216932
    6922 float fdim( float, float );$\indexc{fdim}$
     6933float fdim( float, float );§\indexc{fdim}§
    69236934double fdim( double, double );
    69246935long double fdim( long double, long double );
    69256936
    6926 float nan( const char * );$\indexc{nan}$
     6937float nan( const char * );§\indexc{nan}§
    69276938double nan( const char * );
    69286939long double nan( const char * );
    … …  
    69346945\leavevmode
    69356946\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6936 float exp( float );$\indexc{exp}$
     6947float exp( float );§\indexc{exp}§
    69376948double exp( double );
    69386949long double exp( long double );
    … …  
    69416952long double _Complex exp( long double _Complex );
    69426953
    6943 float exp2( float );$\indexc{exp2}$
     6954float exp2( float );§\indexc{exp2}§
    69446955double exp2( double );
    69456956long double exp2( long double );
    … …  
    69486959// long double _Complex exp2( long double _Complex );
    69496960
    6950 float expm1( float );$\indexc{expm1}$
     6961float expm1( float );§\indexc{expm1}§
    69516962double expm1( double );
    69526963long double expm1( long double );
    69536964
    6954 float pow( float, float );$\indexc{pow}$
     6965float pow( float, float );§\indexc{pow}§
    69556966double pow( double, double );
    69566967long double pow( long double, long double );
    … …  
    69656976\leavevmode
    69666977\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    6967 float log( float );$\indexc{log}$
     6978float log( float );§\indexc{log}§
    69686979double log( double );
    69696980long double log( long double );
    … …  
    69726983long double _Complex log( long double _Complex );
    69736984
    6974 float log2( float );$\indexc{log2}$
     6985float log2( float );§\indexc{log2}§
    69756986double log2( double );
    69766987long double log2( long double );
    … …  
    69796990// long double _Complex log2( long double _Complex );
    69806991
    6981 float log10( float );$\indexc{log10}$
     6992float log10( float );§\indexc{log10}§
    69826993double log10( double );
    69836994long double log10( long double );
    … …  
    69866997// long double _Complex log10( long double _Complex );
    69876998
    6988 float log1p( float );$\indexc{log1p}$
     6999float log1p( float );§\indexc{log1p}§
    69897000double log1p( double );
    69907001long double log1p( long double );
    69917002
    6992 int ilogb( float );$\indexc{ilogb}$
     7003int ilogb( float );§\indexc{ilogb}§
    69937004int ilogb( double );
    69947005int ilogb( long double );
    69957006
    6996 float logb( float );$\indexc{logb}$
     7007float logb( float );§\indexc{logb}§
    69977008double logb( double );
    69987009long double logb( long double );
    69997010
    7000 float sqrt( float );$\indexc{sqrt}$
     7011float sqrt( float );§\indexc{sqrt}§
    70017012double sqrt( double );
    70027013long double sqrt( long double );
    … …  
    70057016long double _Complex sqrt( long double _Complex );
    70067017
    7007 float cbrt( float );$\indexc{cbrt}$
     7018float cbrt( float );§\indexc{cbrt}§
    70087019double cbrt( double );
    70097020long double cbrt( long double );
    70107021
    7011 float hypot( float, float );$\indexc{hypot}$
     7022float hypot( float, float );§\indexc{hypot}§
    70127023double hypot( double, double );
    70137024long double hypot( long double, long double );
    … …  
    70197030\leavevmode
    70207031\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7021 float sin( float );$\indexc{sin}$
     7032float sin( float );§\indexc{sin}§
    70227033double sin( double );
    70237034long double sin( long double );
    … …  
    70267037long double _Complex sin( long double _Complex );
    70277038
    7028 float cos( float );$\indexc{cos}$
     7039float cos( float );§\indexc{cos}§
    70297040double cos( double );
    70307041long double cos( long double );
    … …  
    70337044long double _Complex cos( long double _Complex );
    70347045
    7035 float tan( float );$\indexc{tan}$
     7046float tan( float );§\indexc{tan}§
    70367047double tan( double );
    70377048long double tan( long double );
    … …  
    70407051long double _Complex tan( long double _Complex );
    70417052
    7042 float asin( float );$\indexc{asin}$
     7053float asin( float );§\indexc{asin}§
    70437054double asin( double );
    70447055long double asin( long double );
    … …  
    70477058long double _Complex asin( long double _Complex );
    70487059
    7049 float acos( float );$\indexc{acos}$
     7060float acos( float );§\indexc{acos}§
    70507061double acos( double );
    70517062long double acos( long double );
    … …  
    70547065long double _Complex acos( long double _Complex );
    70557066
    7056 float atan( float );$\indexc{atan}$
     7067float atan( float );§\indexc{atan}§
    70577068double atan( double );
    70587069long double atan( long double );
    … …  
    70617072long double _Complex atan( long double _Complex );
    70627073
    7063 float atan2( float, float );$\indexc{atan2}$
     7074float atan2( float, float );§\indexc{atan2}§
    70647075double atan2( double, double );
    70657076long double atan2( long double, long double );
    70667077
    7067 float atan( float, float ); $\C{// alternative name for atan2}$
    7068 double atan( double, double );$\indexc{atan}$
     7078float atan( float, float ); §\C{// alternative name for atan2}§
     7079double atan( double, double );§\indexc{atan}§
    70697080long double atan( long double, long double );
    70707081\end{cfa}
    … …  
    70757086\leavevmode
    70767087\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7077 float sinh( float );$\indexc{sinh}$
     7088float sinh( float );§\indexc{sinh}§
    70787089double sinh( double );
    70797090long double sinh( long double );
    … …  
    70827093long double _Complex sinh( long double _Complex );
    70837094
    7084 float cosh( float );$\indexc{cosh}$
     7095float cosh( float );§\indexc{cosh}§
    70857096double cosh( double );
    70867097long double cosh( long double );
    … …  
    70897100long double _Complex cosh( long double _Complex );
    70907101
    7091 float tanh( float );$\indexc{tanh}$
     7102float tanh( float );§\indexc{tanh}§
    70927103double tanh( double );
    70937104long double tanh( long double );
    … …  
    70967107long double _Complex tanh( long double _Complex );
    70977108
    7098 float asinh( float );$\indexc{asinh}$
     7109float asinh( float );§\indexc{asinh}§
    70997110double asinh( double );
    71007111long double asinh( long double );
    … …  
    71037114long double _Complex asinh( long double _Complex );
    71047115
    7105 float acosh( float );$\indexc{acosh}$
     7116float acosh( float );§\indexc{acosh}§
    71067117double acosh( double );
    71077118long double acosh( long double );
    … …  
    71107121long double _Complex acosh( long double _Complex );
    71117122
    7112 float atanh( float );$\indexc{atanh}$
     7123float atanh( float );§\indexc{atanh}§
    71137124double atanh( double );
    71147125long double atanh( long double );
    … …  
    71237134\leavevmode
    71247135\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7125 float erf( float );$\indexc{erf}$
     7136float erf( float );§\indexc{erf}§
    71267137double erf( double );
    71277138long double erf( long double );
    … …  
    71307141long double _Complex erf( long double _Complex );
    71317142
    7132 float erfc( float );$\indexc{erfc}$
     7143float erfc( float );§\indexc{erfc}§
    71337144double erfc( double );
    71347145long double erfc( long double );
    … …  
    71377148long double _Complex erfc( long double _Complex );
    71387149
    7139 float lgamma( float );$\indexc{lgamma}$
     7150float lgamma( float );§\indexc{lgamma}§
    71407151double lgamma( double );
    71417152long double lgamma( long double );
    … …  
    71447155long double lgamma( long double, int * );
    71457156
    7146 float tgamma( float );$\indexc{tgamma}$
     7157float tgamma( float );§\indexc{tgamma}§
    71477158double tgamma( double );
    71487159long double tgamma( long double );
    … …  
    71547165\leavevmode
    71557166\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7156 float floor( float );$\indexc{floor}$
     7167float floor( float );§\indexc{floor}§
    71577168double floor( double );
    71587169long double floor( long double );
    71597170
    7160 float ceil( float );$\indexc{ceil}$
     7171float ceil( float );§\indexc{ceil}§
    71617172double ceil( double );
    71627173long double ceil( long double );
    71637174
    7164 float trunc( float );$\indexc{trunc}$
     7175float trunc( float );§\indexc{trunc}§
    71657176double trunc( double );
    71667177long double trunc( long double );
    71677178
    7168 float rint( float );$\indexc{rint}$
     7179float rint( float );§\indexc{rint}§
    71697180long double rint( long double );
    71707181long int rint( float );
    … …  
    71757186long long int rint( long double );
    71767187
    7177 long int lrint( float );$\indexc{lrint}$
     7188long int lrint( float );§\indexc{lrint}§
    71787189long int lrint( double );
    71797190long int lrint( long double );
    … …  
    71827193long long int llrint( long double );
    71837194
    7184 float nearbyint( float );$\indexc{nearbyint}$
     7195float nearbyint( float );§\indexc{nearbyint}§
    71857196double nearbyint( double );
    71867197long double nearbyint( long double );
    71877198
    7188 float round( float );$\indexc{round}$
     7199float round( float );§\indexc{round}§
    71897200long double round( long double );
    71907201long int round( float );
    … …  
    71957206long long int round( long double );
    71967207
    7197 long int lround( float );$\indexc{lround}$
     7208long int lround( float );§\indexc{lround}§
    71987209long int lround( double );
    71997210long int lround( long double );
    … …  
    72087219\leavevmode
    72097220\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    7210 float copysign( float, float );$\indexc{copysign}$
     7221float copysign( float, float );§\indexc{copysign}§
    72117222double copysign( double, double );
    72127223long double copysign( long double, long double );
    72137224
    7214 float frexp( float, int * );$\indexc{frexp}$
     7225float frexp( float, int * );§\indexc{frexp}§
    72157226double frexp( double, int * );
    72167227long double frexp( long double, int * );
    72177228
    7218 float ldexp( float, int );$\indexc{ldexp}$
     7229float ldexp( float, int );§\indexc{ldexp}§
    72197230double ldexp( double, int );
    72207231long double ldexp( long double, int );
    72217232
    7222 [ float, float ] modf( float );$\indexc{modf}$
     7233[ float, float ] modf( float );§\indexc{modf}§
    72237234float modf( float, float * );
    72247235[ double, double ] modf( double );
    … …  
    72277238long double modf( long double, long double * );
    72287239
    7229 float nextafter( float, float );$\indexc{nextafter}$
     7240float nextafter( float, float );§\indexc{nextafter}§
    72307241double nextafter( double, double );
    72317242long double nextafter( long double, long double );
    72327243
    7233 float nexttoward( float, long double );$\indexc{nexttoward}$
     7244float nexttoward( float, long double );§\indexc{nexttoward}§
    72347245double nexttoward( double, long double );
    72357246long double nexttoward( long double, long double );
    72367247
    7237 float scalbn( float, int );$\indexc{scalbn}$
     7248float scalbn( float, int );§\indexc{scalbn}§
    72387249double scalbn( double, int );
    72397250long double scalbn( long double, int );
    72407251
    7241 float scalbln( float, long int );$\indexc{scalbln}$
     7252float scalbln( float, long int );§\indexc{scalbln}§
    72427253double scalbln( double, long int );
    72437254long double scalbln( long double, long int );
    … …  
    72567267\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    72577268struct Duration {
    7258         int64_t tv; $\C{// nanoseconds}$
     7269        int64_t tv; §\C{// nanoseconds}§
    72597270};
    72607271
    … …  
    73867397\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    73877398struct Time {
    7388         uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
     7399        uint64_t tv; §\C{// nanoseconds since UNIX epoch}§
    73897400};
    73907401
    … …  
    74577468\begin{cfa}[aboveskip=0pt,belowskip=0pt]
    74587469struct Clock {
    7459         Duration offset; $\C{// for virtual clock: contains offset from real-time}$
    7460         int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
     7470        Duration offset; §\C{// for virtual clock: contains offset from real-time}§
     7471        int clocktype; §\C{// implementation only -1 (virtual), CLOCK\_REALTIME}§
    74617472};
    74627473
    … …  
    74667477void ?{}( Clock & clk, Duration adj );
    74677478
    7468 Duration getResNsec(); $\C{// with nanoseconds}$
    7469 Duration getRes(); $\C{// without nanoseconds}$
    7470 
    7471 Time getTimeNsec(); $\C{// with nanoseconds}$
    7472 Time getTime(); $\C{// without nanoseconds}$
     7479Duration getResNsec(); §\C{// with nanoseconds}§
     7480Duration getRes(); §\C{// without nanoseconds}§
     7481
     7482Time getTimeNsec(); §\C{// with nanoseconds}§
     7483Time getTime(); §\C{// without nanoseconds}§
    74737484Time getTime( Clock & clk );
    74747485Time ?()( Clock & clk );
    … …  
    74867497
    74877498\begin{cfa}
    7488 void ?{}( Int * this ); $\C{// constructor/destructor}$
     7499void ?{}( Int * this ); §\C{// constructor/destructor}§
    74897500void ?{}( Int * this, Int init );
    74907501void ?{}( Int * this, zero_t );
    … …  
    74957506void ^?{}( Int * this );
    74967507
    7497 Int ?=?( Int * lhs, Int rhs ); $\C{// assignment}$
     7508Int ?=?( Int * lhs, Int rhs ); §\C{// assignment}§
    74987509Int ?=?( Int * lhs, long int rhs );
    74997510Int ?=?( Int * lhs, unsigned long int rhs );
    … …  
    75127523unsigned long int narrow( Int val );
    75137524
    7514 int ?==?( Int oper1, Int oper2 ); $\C{// comparison}$
     7525int ?==?( Int oper1, Int oper2 ); §\C{// comparison}§
    75157526int ?==?( Int oper1, long int oper2 );
    75167527int ?==?( long int oper2, Int oper1 );
    … …  
    75487559int ?>=?( unsigned long int oper1, Int oper2 );
    75497560
    7550 Int +?( Int oper ); $\C{// arithmetic}$
     7561Int +?( Int oper ); §\C{// arithmetic}§
    75517562Int -?( Int oper );
    75527563Int ~?( Int oper );
    … …  
    76307641Int ?>>=?( Int * lhs, mp_bitcnt_t shift );
    76317642
    7632 Int abs( Int oper ); $\C{// number functions}$
     7643Int abs( Int oper ); §\C{// number functions}§
    76337644Int fact( unsigned long int N );
    76347645Int gcd( Int oper1, Int oper2 );
    … …  
    76427653Int sqrt( Int oper );
    76437654
    7644 forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp );  $\C{// I/O}$
     7655forall( dtype istype | istream( istype ) ) istype * ?|?( istype * is, Int * mp );  §\C{// I/O}§
    76457656forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
    76467657\end{cfa}
    … …  
    76537664\hline
    76547665\begin{cfa}
    7655 #include <gmp>$\indexc{gmp}$
     7666#include <gmp>§\indexc{gmp}§
    76567667int main( void ) {
    76577668        sout | "Factorial Numbers";
    … …  
    76677678&
    76687679\begin{cfa}
    7669 #include <gmp.h>$\indexc{gmp.h}$
     7680#include <gmp.h>§\indexc{gmp.h}§
    76707681int main( void ) {
    7671         @gmp_printf@( "Factorial Numbers\n" );
    7672         @mpz_t@ fact;
    7673         @mpz_init_set_ui@( fact, 1 );
    7674         @gmp_printf@( "%d %Zd\n", 0, fact );
     7682        ®gmp_printf®( "Factorial Numbers\n" );
     7683        ®mpz_t® fact;
     7684        ®mpz_init_set_ui®( fact, 1 );
     7685        ®gmp_printf®( "%d %Zd\n", 0, fact );
    76757686        for ( unsigned int i = 1; i <= 40; i += 1 ) {
    7676                 @mpz_mul_ui@( fact, fact, i );
    7677                 @gmp_printf@( "%d %Zd\n", i, fact );
     7687                ®mpz_mul_ui®( fact, fact, i );
     7688                ®gmp_printf®( "%d %Zd\n", i, fact );
    76787689        }
    76797690}
    … …  
    77407751\begin{cfa}[belowskip=0pt]
    77417752// implementation
    7742 struct Rational {$\indexc{Rational}$
    7743         long int numerator, denominator; $\C{// invariant: denominator > 0}$
     7753struct Rational {§\indexc{Rational}§
     7754        long int numerator, denominator; §\C{// invariant: denominator > 0}§
    77447755}; // Rational
    77457756
    7746 Rational rational(); $\C{// constructors}$
     7757Rational rational(); §\C{// constructors}§
    77477758Rational rational( long int n );
    77487759Rational rational( long int n, long int d );
    … …  
    77507761void ?{}( Rational * r, one_t );
    77517762
    7752 long int numerator( Rational r ); $\C{// numerator/denominator getter/setter}$
     7763long int numerator( Rational r ); §\C{// numerator/denominator getter/setter}§
    77537764long int numerator( Rational r, long int n );
    77547765long int denominator( Rational r );
    77557766long int denominator( Rational r, long int d );
    77567767
    7757 int ?==?( Rational l, Rational r ); $\C{// comparison}$
     7768int ?==?( Rational l, Rational r ); §\C{// comparison}§
    77587769int ?!=?( Rational l, Rational r );
    77597770int ?<?( Rational l, Rational r );
    … …  
    77627773int ?>=?( Rational l, Rational r );
    77637774
    7764 Rational -?( Rational r ); $\C{// arithmetic}$
     7775Rational -?( Rational r ); §\C{// arithmetic}§
    77657776Rational ?+?( Rational l, Rational r );
    77667777Rational ?-?( Rational l, Rational r );
    … …  
    77687779Rational ?/?( Rational l, Rational r );
    77697780
    7770 double widen( Rational r ); $\C{// conversion}$
     7781double widen( Rational r ); §\C{// conversion}§
    77717782Rational narrow( double f, long int md );
    77727783
Note: See TracChangeset for help on using the changeset viewer.