Changes in doc/user/user.tex [45576af9:e229c22]

File:

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

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Fri Jun 10 16:38:22 2016
-%% Update Count     : 394
+%% Last Modified On : Fri Jun  3 09:49:31 2016
+%% Update Count     : 281
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -18 +18 @@
 
 % inline code ©...© (copyright symbol) emacs: C-q M-)
-% red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
-% blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
-% green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
-% Latex escape §...§ (section symbol) emacs: C-q M-'
+% red highlighting ®...® (registered trademark sumbol) emacs: C-q M-.
+% latex escape §...§ (section symbol) emacs: C-q M-'
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
 
-\documentclass[twoside,11pt]{article}
+\documentclass[openright,twoside]{article}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -34 +32 @@
 \usepackage{fullpage,times,comment}
 \usepackage{epic,eepic}
-\usepackage{upquote}                                                                    % switch curled `'" to straight `'"
+\usepackage{upquote}                                                                    % switch curled `' to straight `'
 \usepackage{xspace}
 \usepackage{varioref}                                                                   % extended references
 \usepackage{listings}                                                                   % format program code
-\usepackage[flushmargin]{footmisc}                                              % support label/reference in footnote
+\usepackage{footmisc}                                                                   % support label/reference in footnote
 \usepackage{latexsym}                                   % \Box glyph
 \usepackage{mathptmx}                                   % better math font with "times"
-\usepackage[usenames]{color}
 \usepackage[pagewise]{lineno}
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\input{common}                                          % bespoke macros used in the document
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 \usepackage{breakurl}
 \renewcommand{\UrlFont}{\small\sf}
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Bespoke macros used in the document.
+\input{common}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
 % Names used in the document.
 
 \newcommand{\Version}{1.0.0}
 \newcommand{\CS}{C\raisebox{-0.9ex}{\large$^\sharp$}\xspace}
-
-\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
-\newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
-\newcommand{\R}[1]{\Textbf{#1}}
-\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
-\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -113 +110 @@
 
 \CFA\footnote{Pronounced ``C-for-all'', and written \CFA, CFA, or \CFL.} is a modern general-purpose programming-language, designed an as evolutionary step forward from the C programming language.
-The syntax of the \CFA language builds from C, and should look immediately familiar to C/\CC programmers.
+The syntax of the \CFA language builds from C, and should look immediately familiar to C programmers.
 % Any language feature that is not described here can be assumed to be using the standard C11 syntax.
-\CFA adds many modern programming-language features that directly lead to increased \emph{safety} and \emph{productivity}, while maintaining interoperability with existing C programs and achieving C performance.
+\CFA adds many modern programming-language features that directly leads to increased \emph{safety} and \emph{productivity}, while maintaining interoperability with existing C programs and achieving C performance.
 Like C, \CFA is a statically typed, procedural language with a low-overhead runtime, meaning there is no global garbage-collection.
 The primary new features include parametric-polymorphism routines and types, exceptions, concurrency, and modules.
@@ -126 +123 @@
 New programs can be written in \CFA using a combination of C and \CFA features.
 \CC had a similar goal 30 years ago, but has struggled over the intervening time to incorporate modern programming-language features because of early design choices.
-\CFA has 30 years of hindsight and a clean starting point.
+\CFA has 30 years of hindsight and clean starting point.
 
 Like \CC, there may be both an old and new ways to achieve the same effect.
 For example, the following programs compare the \CFA and C I/O mechanisms.
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 #include <fstream>
 int main( void ) {
         int x = 0, y = 1, z = 2;
-        ®sout | x | y | z | endl;®
+        sout | x | y | z | endl;
 }
 \end{lstlisting}
@@ -145 +142 @@
 int main( void ) {
         int x = 0, y = 1, z = 2;
-        ®printf( "%d %d %d\n", x, y, z );®
+        printf( "%d %d %d\n", x, y, z );
 }
 \end{lstlisting}
@@ -151 +148 @@
 \end{quote2}
 Both programs output the same result.
-While the \CFA I/O looks similar to the \CC output style, there are important differences, such as automatic spacing between variables as in Python (see also~\VRef{s:IOLibrary}).
-
-This document is a user manual for the \CFA programming language, targeted at \CFA programmers.
+While the \CFA I/O looks similar to the \CC output style, there are several important differences, such as automatic spacing between variables as in Python (see also~\VRef{s:IOLibrary}).
+
+This document is a reference manual for the \CFA programming language, targeted at \CFA programmers.
 Implementers may refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 In its current state, this document covers the intended core features of the language.
@@ -162 +159 @@
 \section{History}
 
-The \CFA project started with K-W C~\cite{Buhr94a,Till89}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.
+The \CFA project started with K-W C~\cite{Till89,Buhr94a}, which extended C with new declaration syntax, multiple return values from routines, and extended assignment capabilities using the notion of tuples.
 (See~\cite{Werther96} for some similar work, but for \CC.)
 The original \CFA project~\cite{Ditchfield92} extended the C type system with parametric polymorphism and overloading, as opposed to the \CC approach of object-oriented extensions to the C type-system.
 A first implementation of the core Cforall language was created~\cite{Bilson03,Esteves04}, but at the time there was little interesting in extending C, so work did not continue.
-As the saying goes, ``What goes around, comes around.'', and there is now renewed interest in the C programming language because of legacy code-bases, so the \CFA project has been restarted.
+As the saying goes, ``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.
 
 
@@ -172 +169 @@
 
 Even with all its problems, C is a very popular programming language because it allows writing software at virtually any level in a computer system without restriction.
-For system programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
+For systems programming, where direct access to hardware and dealing with real-time issues is a requirement, C is usually the language of choice.
 As well, there are millions of lines of C legacy code, forming the base for many software development projects (especially on UNIX systems).
 The TIOBE index (\url{http://www.tiobe.com/tiobe_index}) for March 2016 shows programming-language popularity, with Java 20.5\%, C 14.5\%, \CC 6.7\%, \CS 4.3\%, Python 4.3\%, and all other programming languages below 3\%.
-As well, for 30 years, C has been the number 1 and 2 most popular programming language:
-\begin{center}
-\setlength{\tabcolsep}{1.5ex}
-\begin{tabular}{@{}r|c|c|c|c|c|c|c@{}}
-Ranking & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986          \\
-\hline
-Java    & 1             & 1             & 1             & 3             & 29    & -             & -                     \\
-\hline
-\R{C}   & \R{2} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1}         \\
-\hline
-\CC             & 3             & 3             & 3             & 2             & 2             & 2             & 7                     \\
-\end{tabular}
-\end{center}
 Hence, C is still an extremely important programming language, with double the usage of \CC, where \CC itself is largely C code.
 Finally, love it or hate it, C has been an important and influential part of computer science for 40 years and it appears it will continue to be for many more years.
@@ -194 +178 @@
 The goal of this project is to engineer modern language features into C in an evolutionary rather than revolutionary way.
 \CC~\cite{c++,ANSI14:C++} is an example of a similar project;
-however, it largely extended the language, and did not address many existing problems.\footnote{%
+however, it largely extended the language, and did not address existing problems.\footnote{%
 Two important existing problems addressed were changing the type of character literals from ©int© to ©char© and enumerator from ©int© to the type of its enumerators.}
-Fortran~\cite{Fortran08}, Ada~\cite{Ada12}, and Cobol~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features (e.g., objects, concurrency) are added and problems fixed within the framework of the existing language.
+Fortran~\cite{Fortran08}, Ada~\cite{Ada12}, and Cobol~\cite{Cobol14} are examples of programming languages that took an evolutionary approach, where modern language features are added and problems fixed within the framework of the existing language.
 Java~\cite{Java8}, Go~\cite{Go}, Rust~\cite{Rust} and D~\cite{D} are examples of the revolutionary approach for modernizing C/\CC, resulting in a new language rather than an extension of the descendent.
 These languages have different syntax and semantics from C, and do not interoperate directly with C, largely because of garbage collection.
 As a result, there is a significant learning curve to move to these languages, and C legacy-code must be rewritten.
-These costs can be prohibitive for many companies with a large software base in C/\CC, and a significant number of programmers requiring retraining to a new programming language.
-
-The result of this project is a language that is largely backwards compatible with C11~\cite{C11}, but fixing some of the well known C problems and containing many modern language features.
-Without significant extension to the C programming language, it is becoming unable to cope with the needs of modern programming problems and programmers;
+These costs can be prohibitive for many companies with a large software base in C/\CC, and many programmers that require retraining to a new programming language.
+
+The result of this project is a language that is largely backwards compatible with C11~\cite{C11}, but containing many modern language features and fixing some of the well known C problems.
+Without significant extension to the C programming language, C will be unable to cope with the needs of modern programming problems and programmers;
 as a result, it will fade into disuse.
 Considering the large body of existing C code and programmers, there is significant impetus to ensure C is transformed into a modern programming language.
@@ -216 +200 @@
 This feature allows users of \CFA to take advantage of the existing panoply of C libraries from inside their \CFA code.
 In fact, one of the biggest issues for any new programming language is establishing a minimum level of library code to support a large body of activities.
-Language developers often state that adequate library support takes more work than designing and implementing the language itself.
+Programming-language developers often state that adequate library support takes more work than designing and implementing the language itself.
 Like \CC, \CFA starts with immediate access to all exiting C libraries, and in many cases, can easily wrap library routines with simpler and safer interfaces, at very low cost.
-Hence, \CFA begins by leveraging the large repository of C libraries with little cost.
 
 However, it is necessary to differentiate between C and \CFA code because of name overloading, as for \CC.
-For example, the C math-library provides the following routines for computing the absolute value of the basic types: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
-Whereas, \CFA wraps each of these routines into ones with the common name ©abs©:
+For example, the C math-library provides the following routines for computing the absolute value of the basic type: ©abs©, ©labs©, ©llabs©, ©fabs©, ©fabsf©, ©fabsl©, ©cabsf©, ©cabs©, and ©cabsl©.
+Whereas, \CFA wraps each of these routines into one with the common name ©abs©.
 \begin{lstlisting}
 char abs( char );
 extern "C" {
-int abs( int );                                 // use default C routine for int
+int abs( int );                         // use default C routine for int
 } // extern "C"
 long int abs( long int );
@@ -250 +233 @@
 \section[Compiling CFA Program]{Compiling \CFA Program}
 
-The command ©cfa© is used to compile \CFA program(s), and is based on the GNU ©gcc©\index{gcc} command, e.g.:
+The command ©cfa© is used to compile \CFA program(s).
+This command works like the GNU ©gcc©\index{gcc} command, e.g.:
 \begin{lstlisting}
 cfa§\indexc{cfa}\index{compilation!cfa@©cfa©}§ [ gcc-options ] C/§\CFA§-files [ assembler/loader-files ]
@@ -256 +240 @@
 By default, \CFA programs having the following ©gcc© flags turned on:
 \begin{description}
-\item\hspace*{-0.6ex}\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}}
+\item\hspace*{-4pt}\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}}
 The 1999 C standard plus GNU extensions.
-\item\hspace*{-0.6ex}\Indexc{-fgnu89-¶inline¶}\index{compilation option!-fgnu89-inline@{©-fgnu89-¶inline¶©}}
+\item\hspace*{-4pt}\Indexc{-fgnu89-¶inline¶}\index{compilation option!-fgnu89-inline@{©-fgnu89-¶inline¶©}}
 Use the traditional GNU semantics for inline routines in C99 mode, which allows inline routines in header files.
 \end{description}
 The following new \CFA option is available:
 \begin{description}
-\item\hspace*{-0.6ex}\Indexc{-CFA}\index{compilation option!-CFA@{©-CFA©}}
+\item\hspace*{-4pt}\Indexc{-CFA}\index{compilation option!-CFA@{©-CFA©}}
 Only the C preprocessor and the \CFA translator steps are performed and the transformed program is written to standard output, which makes it possible to examine the code generated by the \CFA translator.
 \end{description}
@@ -269 +253 @@
 The following preprocessor variables are available:
 \begin{description}
-\item\hspace*{-0.6ex}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@{©__CFA__©}}
+\item\hspace*{-4pt}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@{©__CFA__©}}
 is always available during preprocessing and its value is the current major \Index{version number} of \CFA.\footnote{
 The C preprocessor allows only integer values in a preprocessor variable so a value like ``\Version'' is not allowed.
 Hence, the need to have three variables for the major, minor and patch version number.}
 
-\item\hspace*{-0.6ex}\Indexc{__CFA_MINOR__}\index{preprocessor variables!__CFA_MINOR__@{©__CFA_MINOR__©}}
+\item\hspace*{-4pt}\Indexc{__CFA_MINOR__}\index{preprocessor variables!__CFA_MINOR__@{©__CFA_MINOR__©}}
 is always available during preprocessing and its value is the current minor \Index{version number} of \CFA.
 
-\item\hspace*{-0.6ex}\Indexc{__CFA_PATCH__}\index{preprocessor variables!__CFA_PATCH__@©__CFA_PATCH__©}
+\item\hspace*{-4pt}\Indexc{__CFA_PATCH__}\index{preprocessor variables!__CFA_PATCH__@©__CFA_PATCH__©}
 is always available during preprocessing and its value is the current patch \Index{version number} of \CFA.
 
-\item\hspace*{-0.6ex}\Indexc{__CFA__}\index{preprocessor variables!__CFA__@©__CFA__©} and \Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}
-are always available during preprocessing and have no value.
+\item\hspace*{-4pt}\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}
+is always available during preprocessing and it has no value.
 \end{description}
 
@@ -288 +272 @@
 \begin{lstlisting}
 #ifndef __CFORALL__
-#include <stdio.h>                              // C header file
+#include <stdio.h>                      // C header file
 #else
-#include <fstream>                              // §\CFA{}§ header file
+#include <fstream>                      // §\CFA{}§ header file
 #endif
 \end{lstlisting}
@@ -300 +284 @@
 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
 \begin{lstlisting}
-2®_®147®_®483®_®648;                                    // decimal constant
-56_ul;                                                  // decimal unsigned long constant
-0_377;                                                  // octal constant
-0x_ff_ff;                                               // hexadecimal constant
-0x_ef3d_aa5c;                                   // hexadecimal constant
-3.141_592_654;                                  // floating point constant
-10_e_+1_00;                                             // floating point constant
-0x_ff_ff_p_3;                                   // hexadecimal floating point
-0x_1.ffff_ffff_p_128_l;                 // hexadecimal floating point long constant
-L_"\x_ff_ee";                                   // wide character constant
+2®_®147®_®483®_®648;                            // decimal constant
+56_ul;                                          // decimal unsigned long constant
+0_377;                                          // octal constant
+0x_ff_ff;                                       // hexadecimal constant
+0x_ef3d_aa5c;                           // hexadecimal constant
+3.141_592_654;                          // floating point constant
+10_e_+1_00;                                     // floating point constant
+0x_ff_ff_p_3;                           // hexadecimal floating point
+0x_1.ffff_ffff_p_128_l;         // hexadecimal floating point long constant
+L_"\x_ff_ee";                           // wide character constant
 \end{lstlisting}
 The rules for placement of underscores is as follows:
@@ -327 +311 @@
 \end{enumerate}
 It is significantly easier to read and enter long constants when they are broken up into smaller groupings (most cultures use comma or period among digits for the same purpose).
-This extension is backwards compatible, matches with the use of underscore in variable names, and appears in Ada and Java 8.
+This extension is backwards compatible, matches with the use of underscore in variable names, and appears in Ada and Java.
 
 
@@ -337 +321 @@
 \begin{quote2}
 \begin{tabular}{@{}ll@{}}
-\begin{lstlisting}
-int *x[5]
+\begin{lstlisting}[aboveskip=0pt,belowskip=0pt]
+int *x[ 5 ]
 \end{lstlisting}
 &
@@ -348 +332 @@
 For example, a routine returning a pointer to an array of integers is defined and used in the following way:
 \begin{lstlisting}
-int (*f())[5] {...};                    // definition mimics usage
-... (*f())[3] += 1;
+int (*f())[ 5 ] {...};  // definition mimics usage
+... (*f())[ 3 ] += 1;
 \end{lstlisting}
 Essentially, the return type is wrapped around the routine name in successive layers (like an onion).
 While attempting to make the two contexts consistent was a laudable goal, it has not worked out in practice.
 
-\CFA provides its own type, variable and routine declarations, using a different syntax.
-The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type.
-In the following example, \R{red} is for the base type and \B{blue} is for the qualifiers.
-The \CFA declarations move the qualifiers to the left of the base type, i.e., blue to the left of the red, while the qualifiers have the same meaning but are ordered left to left to right to specify the variable's type.
-\begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
-\begin{lstlisting}
-ß[5] *ß ®int® x1;
-ß* [5]ß ®int® x2;
-ß[* [5] int]ß f®( int p )®;
-\end{lstlisting}
-&
-\begin{lstlisting}
-®int® ß*ß x1 ß[5]ß;
-®int® ß(*ßx2ß)[5]ß;
-ßint (*ßf®( int p )®ß)[5]ß;
-\end{lstlisting}
-\end{tabular}
-\end{quote2}
+\CFA provides its own type, variable and routine declarations, using a slightly different syntax.
+The new declarations place modifiers to the left of the base type, while C declarations place modifiers to the right of the base type.
 The only exception is bit field specification, which always appear to the right of the base type.
-% Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
-However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
+C and the new \CFA declarations may appear together in the same program block, but cannot be mixed within a specific declaration.
+
+In \CFA declarations, the same tokens are used as in C: the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array, and parentheses ©()© are used to indicate a routine parameter.
+However, unlike C, \CFA type declaration tokens are specified from left to right and the entire type specification is distributed across all variables in the declaration list.
 For instance, variables ©x© and ©y© of type pointer to integer are defined in \CFA as follows:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
-\begin{lstlisting}
-®*® int x, y;
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{lstlisting}
+®* int x, y;®
 \end{lstlisting}
 &
 \begin{lstlisting}
-int ®*®x, ®*®y;
+int *x, *y;
 \end{lstlisting}
 \end{tabular}
@@ -392 +360 @@
 Other examples are:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
 [ 5 ] int z;
@@ -429 +397 @@
 \end{quote2}
 
-All type qualifiers, e.g., ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, e.g.:
+All type qualifiers, i.e., ©const© and ©volatile©, are used in the normal way with the new declarations but appear left to right, e.g.:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
-\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
 const * const int x;
@@ -449 +417 @@
 \end{tabular}
 \end{quote2}
-All declaration qualifiers, e.g., ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
+All declaration qualifiers, i.e., ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} e.g.:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
 extern [ 5 ] int x;
@@ -475 +443 @@
 e.g.:
 \begin{lstlisting}
-x;                                                              // int x
-*y;                                                             // int *y
-f( p1, p2 );                                    // int f( int p1, int p2 );
-f( p1, p2 ) {}                                  // int f( int p1, int p2 ) {}
-\end{lstlisting}
-
-Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
+x;                                              // int x
+*y;                                             // int *y
+f( p1, p2 );                    // int f( int p1, int p2 );
+f( p1, p2 ) {}                  // int f( int p1, int p2 ) {}
+\end{lstlisting}
+
+As stated above, the two styles of declaration may appear together in the same block.
 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
@@ -490 +458 @@
 The new declaration syntax can be used in other contexts where types are required, e.g., casts and the pseudo-routine ©sizeof©:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
-\begin{lstlisting}
-y = (®* int®)x;
-i = sizeof(®[ 5 ] * int®);
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{lstlisting}
+y = (* int)x;
+i = sizeof([ 5 ] * int);
 \end{lstlisting}
 &
 \begin{lstlisting}
-y = (®int *®)x;
-i = sizeof(®int *[ 5 ]®);
+y = (int *)x;
+i = sizeof(int *[ 5 ]);
 \end{lstlisting}
 \end{tabular}
@@ -508 +476 @@
 
 \CFA also supports a new syntax for routine definition, as well as ISO C and K\&R routine syntax.
-The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, e.g.:
+The point of the new syntax is to allow returning multiple values from a routine~\cite{CLU,Galletly96}, e.g.:
 \begin{lstlisting}
 ®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
@@ -522 +490 @@
 Declaration qualifiers can only appear at the start of a routine definition, e.g.:
 \begin{lstlisting}
-®extern® [ int x ] g( int y ) {§\,§}
+extern [ int x ] g( int y ) {§\,§}
 \end{lstlisting}
 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
 in 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:
 \begin{lstlisting}
-[§\,§] g();                                                     // no input or output parameters
-[ void ] g( void );                             // no input or output parameters
+[§\,§] g();                                             // no input or output parameters
+[ void ] g( void );                     // no input or output parameters
 \end{lstlisting}
 
@@ -535 +503 @@
 [ i, j, ch ] = f( 3, 'a', ch );
 \end{lstlisting}
-The list of return values from f and the grouping on the left-hand side of the assignment is called a \newterm{return list} and discussed in Section 12.
+The list of return values from f and the grouping on the left-hand side of the assignment is called a tuple and discussed in Section 12.
 
 \CFA style declarations cannot be used to declare parameters for K\&R style routine definitions because of the following ambiguity:
@@ -546 +514 @@
 \begin{lstlisting}
 typedef int foo;
-int f( int (* foo) );                   // foo is redefined as a parameter name
+int f( int (* foo) );           // foo is redefined as a parameter name
 \end{lstlisting}
 The 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.
-The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type qualifier characters appearing to the right of the type name.
+The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type modifier characters appearing to the right of the type name.
 The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts.
 
 C-style declarations can be used to declare parameters for \CFA style routine definitions, e.g.:
 \begin{lstlisting}
-[ int ] f( * int, int * );              // returns an integer, accepts 2 pointers to integers
-[ * int, int * ] f( int );              // returns 2 pointers to integers, accepts an integer
+[ int ] f( * int, int * );      // returns an integer, accepts 2 pointers to integers
+[ * int, int * ] f( int );      // returns 2 pointers to integers, accepts an integer
 \end{lstlisting}
 The 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:
 \begin{lstlisting}
 #define ptoa( n, d ) int (*n)[ d ]
-int f( ptoa( p, 5 ) ) ...               // expands to int f( int (*p)[ 5 ] )
-[ int ] f( ptoa( p, 5 ) ) ...   // expands to [ int ] f( int (*p)[ 5 ] )
+int f( ptoa(p,5) ) ...          // expands to int f( int (*p)[ 5 ] )
+[ int ] f( ptoa(p,5) ) ...      // expands to [ int ] f( int (*p)[ 5 ] )
 \end{lstlisting}
 Again, programmers are highly encouraged to use one declaration form or the other, rather than mixing the forms.
 
 
-\subsection{Named Return Values}
-
-\Index{Named return values} handle the case where it is necessary to define a local variable whose value is then returned in a ©return© statement, as in:
+\subsection{Returning Values}
+
+Named return values handle the case where it is necessary to define a local variable whose value is then returned in a ©return© statement, as in:
 \begin{lstlisting}
 int f() {
@@ -577 +545 @@
 \end{lstlisting}
 Because the value in the return variable is automatically returned when a \CFA routine terminates, the ©return© statement \emph{does not} contain an expression, as in:
-\newline
-\begin{minipage}{\linewidth}
-\begin{lstlisting}
-®[ int x, int y ]® f() {
-        int z;
-        ... x = 0; ... y = z; ...
-        ®return;® // implicitly return x, y
-}
-\end{lstlisting}
-\end{minipage}
-\newline
-When the return is encountered, the current values of ©x© and ©y© are returned to the calling routine.
+\begin{lstlisting}
+®[ int x ]® f() {
+        ... x = 0; ... x = y; ...
+        ®return;® // implicitly return x
+}
+\end{lstlisting}
+When the return is encountered, the current value of ©x© is returned to the calling routine.
 As well, ``falling off the end'' of a routine without a ©return© statement is permitted, as in:
 \begin{lstlisting}
-[ int x, int y ] f() {
-        ...
-} // implicitly return x, y
-\end{lstlisting}
-In this case, the current values of ©x© and ©y© are returned to the calling routine just as if a ©return© had been encountered.
+[ int x ] f() {
+        ... x = 0; ... x = y; ...
+} // implicitly return x
+\end{lstlisting}
+In this case, the current value of ©x© is returned to the calling routine just as if a ©return© had been encountered.
 
 
@@ -603 +566 @@
 as well, parameter names are optional, e.g.:
 \begin{lstlisting}
-[ int x ] f ();                                 // returning int with no parameters
-[ * int ] g (int y);                    // returning pointer to int with int parameter
-[ ] h (int,char);                               // returning no result with int and char parameters
-[ * int,int ] j (int);                  // returning pointer to int and int, with int parameter
+[ int x ] f ();                         // returning int with no parameters
+[ * int ] g (int y);            // returning pointer to int with int parameter
+[ ] h (int,char);                       // returning no result with int and char parameters
+[ * int,int ] j (int);          // returning pointer to int and int, with int parameter
 \end{lstlisting}
 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
 It is possible to declare multiple routine-prototypes in a single declaration, but the entire type specification is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), e.g.:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 [ int ] f(int), g;
@@ -641 +604 @@
 for example, the following is incorrect:
 \begin{lstlisting}
-* [ int x ] f () fp;                    // routine name "f" is not allowed
+* [ int x ] f () fp;            // routine name "f" is not allowed
 \end{lstlisting}
 
@@ -774 +737 @@
 While in theory default arguments can be simulated with overloading, as in:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}}   & \multicolumn{1}{c}{\textbf{overloading}}      \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{default arguments}}  & \multicolumn{1}{c}{\textbf{overloading}}      \\
 \begin{lstlisting}
 void p( int x, int y = 2, int z = 3 ) {...}
@@ -810 +773 @@
 \CFA allows \Index{type nesting}, and type qualification of the nested types, where as C hoists\index{type hoisting} (refactors) nested types into the enclosing scope and has no type qualification.
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l|l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{C Type Nesting}}     & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
 \hline
 \begin{lstlisting}
@@ -917 +880 @@
 
 
-\section{Lexical List}
+\section{Tuples}
 
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list for a routine call.
 (More contexts are added shortly.)
-A list of such elements is called a \newterm{lexical list}.
-The general syntax of a lexical list is:
+A list of such elements is called a tuple.
+The general syntax of a tuple is:
 \begin{lstlisting}
 [ §\emph{exprlist}§ ]
 \end{lstlisting}
 where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
-The brackets, ©[]©, allow differentiating between lexical lists and expressions containing the C comma operator.
-The following are examples of lexical lists:
+The brackets, ©[]©, allow differentiating between tuples and expressions containing the C comma operator.
+The following are examples of tuples:
 \begin{lstlisting}
 [ x, y, z ]
@@ -1217 +1180 @@
 \begin{figure}
 \centering
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 ®L1:® for ( ... ) {
@@ -1248 +1211 @@
 \vspace*{0.25in}
 
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 ®L1®: for ( ... ) {
@@ -1490 +1453 @@
 Therefore, the ©case© clause is extended with a list of values, as in:
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{C}}        \\
 \begin{lstlisting}
 switch ( i ) {
@@ -1522 +1485 @@
 In addition, two forms of subranges are allowed to specify case values: the GNU C form and a new \CFA form.
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}}     \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c@{\hspace{20pt}}}{\textbf{GNU C}}    \\
 \begin{lstlisting}
 switch ( i ) {
@@ -2044 +2007 @@
 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization expression type.
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}ll@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CC}} & \multicolumn{1}{c}{©gcc©}\index{gcc} \\
+\begin{tabular}{@{}l@{\hspace{30pt}}ll@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{©gcc©}\index{gcc} \\
 \begin{lstlisting}
 
@@ -4147 +4110 @@
 The general case is printing out a sequence of variables separated by whitespace.
 \begin{quote2}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{\CC}}      \\
 \begin{lstlisting}
 int x = 0, y = 1, z = 2;