Changes in doc/user/user.tex [128c4e4:c6dc7f2]

File:

• doc/user/user.tex (modified) (24 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 : Mon Oct  5 08:57:29 2020
-%% Update Count     : 3998
+%% Last Modified On : Sat Jul 13 18:36:18 2019
+%% Update Count     : 3876
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -30 +30 @@
 \usepackage{upquote}                                                                    % switch curled `'" to straight
 \usepackage{calc}
+\usepackage{xspace}
 \usepackage{varioref}                                                                   % extended references
-\usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt]{subfig}
-\renewcommand{\thesubfigure}{\alph{subfigure})}
+\usepackage{listings}                                                                   % format program code
 \usepackage[flushmargin]{footmisc}                                              % support label/reference in footnote
 \usepackage{latexsym}                                   % \Box glyph
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
-\newcommand{\CFALatin}{}
+\input{common}                                          % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\CFAStyle                                                                                               % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
+{}
+
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
@@ -45 +68 @@
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
-\input{common}                                          % common CFA document macros
-\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\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
-
-\usepackage[pagewise]{lineno}
-\renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\usepackage[firstpage]{draftwatermark}
-\SetWatermarkLightness{0.9}
-
-% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
-% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
-% AFTER HYPERREF.
-\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
-
-\setlength{\topmargin}{-0.45in}                                                 % move running title into header
-\setlength{\headsep}{0.25in}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\CFAStyle                                                                                               % use default CFA format-style
-\lstnewenvironment{C++}[1][]                            % use C++ style
-{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
-{}
-
-\newsavebox{\myboxA}
-\newsavebox{\myboxB}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -84 +79 @@
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 \newcommand{\KWC}{K-W C\xspace}
+
+\newsavebox{\LstBox}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -214 +211 @@
 Even with all its problems, C continues to be popular because it allows writing software at virtually any level in a computer system without restriction.
 For system programming, where direct access to hardware, storage management, and real-time issues are a requirement, C is usually the only language of choice.
-The 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.
-The top 4 rankings over the past 35 years are:
+The TIOBE index~\cite{TIOBE} for July 2018 ranks the top five most \emph{popular} programming languages as \Index*{Java} 16\%, C 14\%, \Index*[C++]{\CC{}} 7.5\%, Python 6\%, Visual Basic 4\% = 47.5\%, where the next 50 languages are less than 4\% each, with a long tail.
+The top 3 rankings over the past 30 years are:
 \begin{center}
 \setlength{\tabcolsep}{10pt}
-\begin{tabular}{@{}rcccccccc@{}}
-                & 2020  & 2015  & 2010  & 2005  & 2000  & 1995  & 1990  & 1985  \\ \hline
-Java    & 1             & 2             & 1             & 2             & 3             & -             & -             & -             \\
-\R{C}   & \R{2} & \R{1} & \R{2} & \R{1} & \R{1} & \R{2} & \R{1} & \R{1} \\
-Python  & 3             & 7             & 6             & 6             & 22    & 21    & -             & -             \\
-\CC             & 4             & 4             & 4             & 3             & 2             & 1             & 2             & 12    \\
+\begin{tabular}{@{}rccccccc@{}}
+                & 2018  & 2013  & 2008  & 2003  & 1998  & 1993  & 1988  \\ \hline
+Java    & 1             & 2             & 1             & 1             & 16    & -             & -             \\
+\R{C}   & \R{2} & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} \\
+\CC             & 3             & 4             & 3             & 3             & 2             & 2             & 5             \\
 \end{tabular}
 \end{center}
@@ -256 +252 @@
 
 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
-\begin{cfa}
+\begin{lstlisting}
 ®forall( otype T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§
-\end{cfa}
+\end{lstlisting}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}.
@@ -278 +274 @@
 \begin{comment}
 A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating array:
-\begin{cfa}
+\begin{lstlisting}
 void * bsearch( const void * key, const void * base, size_t dim, size_t size,
                                 int (* compar)( const void *, const void * ));
@@ -287 +283 @@
 double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§
-\end{cfa}
+\end{lstlisting}
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
-\begin{cfa}
+\begin{lstlisting}
 forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
         int comp( const void * t1, const void * t2 ) { /* as above with double changed to T */ }
@@ -300 +296 @@
 double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§
 int posn = bsearch( 5.0, vals, 10 );
-\end{cfa}
+\end{lstlisting}
 The nested function ©comp© provides the hidden interface from typed \CFA to untyped (©void *©) C, plus the cast of the result.
 Providing a hidden ©comp© function in \CC is awkward as lambdas do not use C calling-conventions and template declarations cannot appear at block scope.
@@ -308 +304 @@
 \CFA has replacement libraries condensing hundreds of existing C functions into tens of \CFA overloaded functions, all without rewriting the actual computations.
 For example, it is possible to write a type-safe \CFA wrapper ©malloc© based on the C ©malloc©:
-\begin{cfa}
+\begin{lstlisting}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
 int * ip = malloc(); §\C{// select type and size from left-hand side}§
 double * dp = malloc();
 struct S {...} * sp = malloc();
-\end{cfa}
+\end{lstlisting}
 where the return type supplies the type/size of the allocation, which is impossible in most type systems.
 \end{comment}
@@ -516 +512 @@
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
-int ®``®otype = 3; §\C{// make keyword an identifier}§
-double ®``®forall = 3.5;
+int ®`®otype®`® = 3; §\C{// make keyword an identifier}§
+double ®`®forall®`® = 3.5;
 \end{cfa}
 
@@ -528 +524 @@
 // include file uses the CFA keyword "with".
 #if ! defined( with ) §\C{// nesting ?}§
-#define with ®``®with §\C{// make keyword an identifier}§
+#define with ®`®with®`® §\C{// make keyword an identifier}§
 #define __CFA_BFD_H__
 #endif
-§{\color{red}\#\textbf{include\_next} <bfdlink.h>}§ §\C{// must have internal check for multiple expansion}§
+
+®#include_next <bfdlink.h> §\C{// must have internal check for multiple expansion}§
+®
 #if defined( with ) && defined( __CFA_BFD_H__ ) §\C{// reset only if set}§
 #undef with
@@ -578 +576 @@
 \section{Exponentiation Operator}
 
-C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow(x,y)}, to perform the exponentiation operation.
-\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$.
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@©?\?©} and ©?\=?©\index{?\\=?@©\=?©}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
 The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
 
-There are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
+As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
 Integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the exponent is 2).
-Overflow for a large exponent or negative exponent returns zero.
+Overflow from large exponents or negative exponents return zero.
 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
 \begin{cfa}
@@ -591 +589 @@
 1 1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
 \end{cfa}
-Note, ©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.
+Note, ©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.
 Parenthesis are necessary for complex constants or the expression is parsed as ©1.0f+®(®2.0fi \ 3.0f®)®+2.0fi©.
 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
@@ -600 +598 @@
 OT ?®\®?( OT ep, unsigned long int y );
 \end{cfa}
-The user type ©T© must define multiplication, one (©1©), and ©*©.
+The user type ©T© must define multiplication, one, ©1©, and, ©*©.
 
 
@@ -628 +626 @@
 
 
-%\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
-\subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
-
-C restricts the ©case© clause of a ©switch© statement to a single value.
-For multiple ©case© clauses associated with the same statement, it is necessary to have multiple ©case© clauses rather than multiple values.
-Requiring a ©case© clause for each value does not seem to be in the spirit of brevity normally associated with C.
-Therefore, the ©case© clause is extended with a list of values, as in:
+\subsection{Loop Control}
+
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
+\begin{itemize}
+\item
+An empty conditional implies ©1©.
+\item
+The up-to range ©~©\index{~@©~©} means exclusive range [M,N).
+\item
+The up-to range ©~=©\index{~=@©~=©} means inclusive range [M,N].
+\item
+The down-to range ©-~©\index{-~@©-~©} means exclusive range [N,M).
+\item
+The down-to range ©-~=©\index{-~=@©-~=©} means inclusive range [N,M].
+\item
+©@© means put nothing in this field.
+\item
+©0© is the implicit start value;
+\item
+©1© is the implicit increment value.
+\item
+The up-to range uses ©+=© for increment;
+\item
+The down-to range uses ©-=© for decrement.
+\item
+The loop index is polymorphic in the type of the start value or comparison value when start is implicitly ©0©.
+\end{itemize}
+
+\begin{figure}
 \begin{cquote}
-\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
-\begin{cfa}
-switch ( i ) {
-  case ®1, 3, 5®:
-        ...
-  case ®2, 4, 6®:
-        ...
-}
+\begin{tabular}{@{}l|l@{}}
+\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
+\hline
+\begin{cfa}
+sout | nlOff;
+while ®()® { sout | "empty"; break; } sout | nl;
+do { sout | "empty"; break; } while ®()®; sout | nl;
+for ®()® { sout | "empty"; break; } sout | nl;
+for ( ®0® ) { sout | "A"; } sout | "zero" | nl;
+for ( ®1® ) { sout | "A"; } sout | nl;
+for ( ®10® ) { sout | "A"; } sout | nl;
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; } sout | nl;
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; } sout | nl;
+for ( ®0.5 ~ 5.5® ) { sout | "D"; } sout | nl;
+for ( ®5.5 -~ 0.5® ) { sout | "E"; } sout | nl;
+for ( ®i; 10® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; } sout | nl;
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; } sout | nl;
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; } sout | nl;
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; } sout | nl;
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; } sout | nl;
+enum { N = 10 };
+for ( ®N® ) { sout | "N"; } sout | nl;
+for ( ®i; N® ) { sout | i; } sout | nl;
+for ( ®i; N -~ 0® ) { sout | i; } sout | nl;
+const int start = 3, comp = 10, inc = 2;
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; } sout | nl;
+for ( ®i; 1 ~ @® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 10 -~ @® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2 ~ @ ~ 2® ) { if ( i > 10 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 2.1 ~ @ ~ @® ) { if ( i > 10.5 ) break;
+        sout | i; i += 1.7; } sout | nl;
+for ( ®i; 10 -~ @ ~ 2® ) { if ( i < 0 ) break;
+        sout | i; } sout | nl;
+for ( ®i; 12.1 ~ @ ~ @® ) { if ( i < 2.5 ) break;
+        sout | i; i -= 1.7; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 ~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®i; 5 : j; -5 -~ @ ~ 2® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 ~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5® ) { sout | i | j; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : i; 5 : k; 1.5 ~ @® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®j; -5 -~ @ ~ 2 : k; 1.5 ~ @ : i; 5® ) {
+        sout | i | j | k; } sout | nl;
+for ( ®k; 1.5 ~ @ : j; -5 -~ @ ~ 2 : i; 5® ) {
+        sout | i | j | k; } sout | nl;
 \end{cfa}
 &
 \begin{cfa}
-switch ( i ) {
-  case 1: case 3 : case 5:
-        ...
-  case 2: case 4 : case 6:
-        ...
-}
-\end{cfa}
-&
-\begin{cfa}
-
-// odd values
-
-// even values
-
-
+
+empty
+empty
+empty
+zero
+A
+A A A A A A A A A A
+B B B B B
+C C C C C
+D D D D D
+E E E E E
+0 1 2 3 4 5 6 7 8 9
+1 3 5 7 9
+10 8 6 4 2
+0.5 1.5 2.5 3.5 4.5
+5.5 4.5 3.5 2.5 1.5
+2 4 6 8 10
+10 8 6 4 2
+
+N N N N N N N N N N
+0 1 2 3 4 5 6 7 8 9
+10 9 8 7 6 5 4 3 2 1
+
+3 6 9
+
+1 2 3 4 5 6 7 8 9 10
+
+10 9 8 7 6 5 4 3 2 1 0
+
+2 4 6 8 10
+
+2.1 3.8 5.5 7.2 8.9
+
+10 8 6 4 2 0
+
+12.1 10.4 8.7 7 5.3 3.6
+0 -5 1 -4 2 -3 3 -2 4 -1
+0 -5 1 -6 2 -7 3 -8 4 -9
+0 -5 1 -3 2 -1 3 1 4 3
+0 -5 1 -7 2 -9 3 -11 4 -13
+0 -5 1 -4 2 -3 3 -2 4 -1
+0 -5 1 -6 2 -7 3 -8 4 -9
+0 -5 1 -3 2 -1 3 1 4 3
+0 -5 1 -7 2 -9 3 -11 4 -13
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
+
+0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
 \end{cfa}
 \end{tabular}
 \end{cquote}
-In addition, subranges are allowed to specify case values.\footnote{
-gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
-\begin{cfa}
-switch ( i ) {
-  case ®1~5:® §\C{// 1, 2, 3, 4, 5}§
-        ...
-  case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§
-        ...
-}
-\end{cfa}
-Lists of subranges are also allowed.
-\begin{cfa}
-case ®1~5, 12~21, 35~42®:
-\end{cfa}
+\caption{Loop Control Examples}
+\label{f:LoopControlExamples}
+\end{figure}
 
 
@@ -888 +977 @@
 
 
-\subsection{Non-terminating and Labelled \texorpdfstring{\LstKeywordStyle{fallthrough}}{Non-terminating and Labelled fallthrough}}
-
-The ©fallthrough© clause may be non-terminating within a ©case© clause or have a target label to common code from multiple case clauses.
-\begin{center}
-\begin{tabular}{@{}lll@{}}
-\begin{cfa}
-choose ( ... ) {
-  case 3:
-        if ( ... ) {
-                ... ®fallthru;® // goto case 4
-        } else {
-                ...
-        }
-        // implicit break
-  case 4:
-
-
-
-
+%\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
+\subsection{\texorpdfstring{\LstKeywordStyle{case} Statement}{case Statement}}
+
+C restricts the ©case© clause of a ©switch© statement to a single value.
+For multiple ©case© clauses associated with the same statement, it is necessary to have multiple ©case© clauses rather than multiple values.
+Requiring a ©case© clause for each value does not seem to be in the spirit of brevity normally associated with C.
+Therefore, the ©case© clause is extended with a list of values, as in:
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{cfa}
+switch ( i ) {
+  case ®1, 3, 5®:
+        ...
+  case ®2, 4, 6®:
+        ...
+}
 \end{cfa}
 &
 \begin{cfa}
-choose ( ... ) {
-  case 3:
-        ... ®fallthrough common;®
-  case 4:
-        ... ®fallthrough common;®
-
-  ®common:® // below fallthrough
-                          // at case-clause level
-        ...     // common code for cases 3/4
-        // implicit break
-  case 4:
-
-
+switch ( i ) {
+  case 1: case 3 : case 5:
+        ...
+  case 2: case 4 : case 6:
+        ...
+}
 \end{cfa}
 &
 \begin{cfa}
-choose ( ... ) {
-  case 3:
-        choose ( ... ) {
-          case 4:
-                for ( ... ) {
-                        // multi-level transfer
-                        ... ®fallthru common;®
-                }
-                ...
-        }
+
+// odd values
+
+// even values
+
+
+\end{cfa}
+\end{tabular}
+\end{cquote}
+In addition, subranges are allowed to specify case values.\footnote{
+gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
+\begin{cfa}
+switch ( i ) {
+  case ®1~5:® §\C{// 1, 2, 3, 4, 5}§
         ...
-  ®common:® // below fallthrough
-                          // at case-clause level
-\end{cfa}
-\end{tabular}
-\end{center}
-The target label must be below the ©fallthrough© and may not be nested in a control structure, and
-the target label must be at the same or higher level as the containing ©case© clause and located at
-the same level as a ©case© clause; the target label may be case ©default©, but only associated
-with the current ©switch©/©choose© statement.
-
-\begin{figure}
-\begin{tabular}{@{}l|l@{}}
-\multicolumn{1}{c|}{loop control} & \multicolumn{1}{c}{output} \\
-\hline
-\begin{cfa}[xleftmargin=0pt]
-while ®()® { sout | "empty"; break; }
-do { sout | "empty"; break; } while ®()®;
-for ®()® { sout | "empty"; break; }
-for ( ®0® ) { sout | "A"; } sout | "zero";
-for ( ®1® ) { sout | "A"; }
-for ( ®10® ) { sout | "A"; }
-for ( ®= 10® ) { sout | "A"; }
-for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
-for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
-for ( ®0.5 ~ 5.5® ) { sout | "D"; }
-for ( ®5.5 -~ 0.5® ) { sout | "E"; }
-for ( ®i; 10® ) { sout | i; }
-for ( ®i; = 10® ) { sout | i; }
-for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
-for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
-for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
-for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
-for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
-for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
-enum { N = 10 };
-for ( ®N® ) { sout | "N"; }
-for ( ®i; N® ) { sout | i; }
-for ( ®i; N -~ 0® ) { sout | i; }
-const int start = 3, comp = 10, inc = 2;
-for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
-for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
-for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
-for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
-for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
-for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
-for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
-for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
-for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
-for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
-for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
-\end{cfa}
-&
-\begin{cfa}
-empty
-empty
-empty
-zero
-A
-A A A A A A A A A A
-A A A A A A A A A A A
-B B B B B
-C C C C C
-D D D D D
-E E E E E
-0 1 2 3 4 5 6 7 8 9
-0 1 2 3 4 5 6 7 8 9 10
-1 3 5 7 9
-10 8 6 4 2
-0.5 1.5 2.5 3.5 4.5
-5.5 4.5 3.5 2.5 1.5
-2 4 6 8 10
-10 8 6 4 2
-
-N N N N N N N N N N
-0 1 2 3 4 5 6 7 8 9
-10 9 8 7 6 5 4 3 2 1
-
-3 6 9
-1 2 3 4 5 6 7 8 9 10
-10 9 8 7 6 5 4 3 2 1 0
-2 4 6 8 10
-2.1 3.8 5.5 7.2 8.9
-10 8 6 4 2 0
-12.1 10.4 8.7 7. 5.3 3.6
-0 -5 1 -4 2 -3 3 -2 4 -1
-0 -5 1 -6 2 -7 3 -8 4 -9
-0 -5 1 -3 2 -1 3 1 4 3
-0 -5 1 -7 2 -9 3 -11 4 -13
-0 -5 1 -4 2 -3 3 -2 4 -1
-0 -5 1 -6 2 -7 3 -8 4 -9
-0 -5 1 -3 2 -1 3 1 4 3
-0 -5 1 -7 2 -9 3 -11 4 -13
-0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
-0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
-0 -5 1.5 1 -7 2.5 2 -9 3.5 3 -11 4.5 4 -13 5.5
-\end{cfa}
-\end{tabular}
-\caption{Loop Control Examples}
-\label{f:LoopControlExamples}
-\end{figure}
+  case ®10~15:® §\C{// 10, 11, 12, 13, 14, 15}§
+        ...
+}
+\end{cfa}
+Lists of subranges are also allowed.
+\begin{cfa}
+case ®1~5, 12~21, 35~42®:
+\end{cfa}
+
 
 % for ()  => for ( ;; )
@@ -1054 +1040 @@
 
 
-\subsection{Loop Control}
-
-The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
-\begin{itemize}
-\item
-The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
-\item
-An empty conditional implies comparison value of ©1© (true).
-\item
-A comparison N is implicit up-to exclusive range [0,N©®)®©.
-\item
-A comparison ©=© N is implicit up-to inclusive range [0,N©®]®©.
-\item
-The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©.
-\item
-The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©.
-\item
-The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M©®)®©.
-\item
-The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M©®]®©.
-\item
-©0© is the implicit start value;
-\item
-©1© is the implicit increment value.
-\item
-The up-to range uses operator ©+=© for increment;
-\item
-The down-to range uses operator ©-=© for decrement.
-\item
-©@© means put nothing in this field.
-\item
-©:© means start another index.
-\end{itemize}
-
-
 %\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
@@ -1098 +1049 @@
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
 \VRef[Figure]{f:MultiLevelExit} shows ©continue© and ©break© indicating the specific control structure, and the corresponding C program using only ©goto© and labels.
-The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
+The innermost loop has 7 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
 
 \begin{figure}
-\centering
-\begin{lrbox}{\myboxA}
-\begin{cfa}[tabsize=3]
-®Compound:® {
-        ®Try:® try {
-                ®For:® for ( ... ) {
-                        ®While:® while ( ... ) {
-                                ®Do:® do {
-                                        ®If:® if ( ... ) {
-                                                ®Switch:® switch ( ... ) {
-                                                        case 3:
-                                                                ®break Compound®;
-                                                                ®break Try®;
-                                                                ®break For®;      /* or */  ®continue For®;
-                                                                ®break While®;  /* or */  ®continue While®;
-                                                                ®break Do®;      /* or */  ®continue Do®;
-                                                                ®break If®;
-                                                                ®break Switch®;
-                                                        } // switch
-                                                } else {
-                                                        ... ®break If®; ...     // terminate if
-                                                } // if
-                                } while ( ... ); // do
-                        } // while
-                } // for
-        } ®finally® { // always executed
-        } // try
+\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{@{\hspace{\parindentlnth}}c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}   & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\begin{cfa}
+®LC:® {
+        ... §declarations§ ...
+        ®LS:® switch ( ... ) {
+          case 3:
+                ®LIF:® if ( ... ) {
+                        ®LF:® for ( ... ) {
+                                ®LW:® while ( ... ) {
+                                        ... break ®LC®; ...
+                                        ... break ®LS®; ...
+                                        ... break ®LIF®; ...
+                                        ... continue ®LF;® ...
+                                        ... break ®LF®; ...
+                                        ... continue ®LW®; ...
+                                        ... break ®LW®; ...
+                                } // while
+                        } // for
+                } else {
+                        ... break ®LIF®; ...
+                } // if
+        } // switch
 } // compound
 \end{cfa}
-\end{lrbox}
-
-\begin{lrbox}{\myboxB}
-\begin{cfa}[tabsize=3]
+&
+\begin{cfa}
 {
-
-                ®ForC:® for ( ... ) {
-                        ®WhileC:® while ( ... ) {
-                                ®DoC:® do {
-                                        if ( ... ) {
-                                                switch ( ... ) {
-                                                        case 3:
-                                                                ®goto Compound®;
-                                                                ®goto Try®;
-                                                                ®goto ForB®;      /* or */  ®goto ForC®;
-                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
-                                                                ®goto DoB®;      /* or */  ®goto DoC®;
-                                                                ®goto If®;
-                                                                ®goto Switch®;
-                                                        } ®Switch:® ;
-                                                } else {
-                                                        ... ®goto If®; ...      // terminate if
-                                                } ®If:®;
-                                } while ( ... ); ®DoB:® ;
-                        } ®WhileB:® ;
-                } ®ForB:® ;
-
-
-} ®Compound:® ;
-\end{cfa}
-\end{lrbox}
-
-\subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA}
-\hspace{2pt}
-\vrule
-\hspace{2pt}
-\subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB}
+        ... §declarations§ ...
+        switch ( ... ) {
+          case 3:
+                if ( ... ) {
+                        for ( ... ) {
+                                while ( ... ) {
+                                        ... goto ®LC®; ...
+                                        ... goto ®LS®; ...
+                                        ... goto ®LIF®; ...
+                                        ... goto ®LFC®; ...
+                                        ... goto ®LFB®; ...
+                                        ... goto ®LWC®; ...
+                                        ... goto ®LWB®; ...
+                                  ®LWC®: ; } ®LWB:® ;
+                          ®LFC:® ; } ®LFB:® ;
+                } else {
+                        ... goto ®LIF®; ...
+                } ®L3:® ;
+        } ®LS:® ;
+} ®LC:® ;
+\end{cfa}
+&
+\begin{cfa}
+
+
+
+
+
+
+
+// terminate compound
+// terminate switch
+// terminate if
+// continue loop
+// terminate loop
+// continue loop
+// terminate loop
+
+
+
+// terminate if
+
+
+
+\end{cfa}
+\end{tabular}
 \caption{Multi-level Exit}
 \label{f:MultiLevelExit}
@@ -1421 +1380 @@
 try {
         f(...);
-} catch( E e ; §boolean-predicate§ ) {          §\C{// termination handler}§
+} catch( E e ; §boolean-predicate§ ) {          §\C[8cm]{// termination handler}§
         // recover and continue
-} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}§
+} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}\CRT§
         // repair and return
 } finally {
@@ -3486 +3445 @@
 For implicit formatted input, the common case is reading a sequence of values separated by whitespace, where the type of an input constant must match with the type of the input variable.
 \begin{cquote}
-\begin{lrbox}{\myboxA}
+\begin{lrbox}{\LstBox}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 int x;   double y   char z;
@@ -3492 +3451 @@
 \end{lrbox}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{3em}}l@{}}
-\multicolumn{1}{@{}l@{}}{\usebox\myboxA} \\
+\multicolumn{1}{@{}l@{}}{\usebox\LstBox} \\
 \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CC}}       & \multicolumn{1}{c}{\textbf{Python}}   \\
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
@@ -6588 +6547 @@
 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
 All other C header files must be explicitly wrapped in ©extern "C"© to prevent name mangling.
-This 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.
+For \Index*[C++]{\CC{}}, the name-mangling issue is often handled internally in many C header-files through checks for preprocessor variable ©__cplusplus©, which adds appropriate ©extern "C"© qualifiers.
 
 
@@ -6602 +6561 @@
 The storage-management routines extend their C equivalents by overloading, alternate names, providing shallow type-safety, and removing the need to specify the allocation size for non-array types.
 
-C storage management provides the following capabilities:
+Storage management provides the following capabilities:
 \begin{description}
-\item[filled]
-after allocation with a specified character or value.
+\item[fill]
+after allocation the storage is filled with a specified character.
 \item[resize]
-an existing allocation to decreased or increased its size.
-In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied into the new allocation.
+an existing allocation is decreased or increased in size.
+In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
 For an increase in storage size, new storage after the copied data may be filled.
-\item[align]
-an allocation on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes.
+\item[alignment]
+an allocation starts on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes.
 \item[array]
 the allocation size is scaled to the specified number of array elements.
 An array may be filled, resized, or aligned.
 \end{description}
-\VRef[Table]{t:AllocationVersusCapabilities} shows allocation routines supporting different combinations of storage-management capabilities.
-\begin{table}
-\centering
-\begin{minipage}{0.75\textwidth}
-\begin{tabular}{@{}r|l|l|l|l|l@{}}
+The table shows allocation routines supporting different combinations of storage-management capabilities:
+\begin{center}
+\begin{tabular}{@{}r|r|l|l|l|l@{}}
 \multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
 \hline
 C               & ©malloc©                      & no                    & no            & no            & no    \\
                 & ©calloc©                      & yes (0 only)  & no            & no            & yes   \\
-                & ©realloc©                     & copy                  & yes           & no            & no    \\
+                & ©realloc©                     & no/copy               & yes           & no            & no    \\
                 & ©memalign©            & no                    & no            & yes           & no    \\
-                & ©aligned_alloc©\footnote{Same as ©memalign© but size is an integral multiple of alignment, which is universally ignored.}
-                                                        & no                    & no            & yes           & no    \\
                 & ©posix_memalign©      & no                    & no            & yes           & no    \\
-                & ©valloc©                      & no                    & no            & yes (page size)& no   \\
-                & ©pvalloc©\footnote{Same as ©valloc© but rounds size to multiple of page size.}
-                                                        & no                    & no            & yes (page size)& no   \\
 \hline
-\CFA    & ©cmemalign©           & yes (0 only)  & no            & yes           & yes   \\
-                & ©realloc©                     & copy                  & yes           & yes           & no    \\
-                & ©alloc©                       & no                    & yes           & no            & yes   \\
-                & ©alloc_set©           & yes                   & yes           & no            & yes   \\
-                & ©alloc_align©         & no                    & yes           & yes           & yes   \\
-                & ©alloc_align_set©     & yes                   & yes           & yes           & yes   \\
+C11             & ©aligned_alloc©       & no                    & no            & yes           & no    \\
+\hline
+\CFA    & ©alloc©                       & no/copy/yes   & no/yes        & no            & yes   \\
+                & ©align_alloc©         & no/yes                & no            & yes           & yes   \\
 \end{tabular}
-\end{minipage}
-\caption{Allocation Routines versus Storage-Management Capabilities}
-\label{t:AllocationVersusCapabilities}
-\end{table}
-
-\CFA memory management extends the type safety of all allocations by using the type of the left-hand-side type to determine the allocation size and return a matching type for the new storage.
-Type-safe allocation is provided for all C allocation routines and new \CFA allocation routines, \eg in
-\begin{cfa}
-int * ip = (int *)malloc( sizeof(int) );                §\C{// C}§
-int * ip = malloc();                                                    §\C{// \CFA type-safe version of C malloc}§
-int * ip = alloc();                                                             §\C{// \CFA type-safe uniform alloc}§
-\end{cfa}
-the latter two allocations determine the allocation size from the type of ©p© (©int©) and cast the pointer to the allocated storage to ©int *©.
-
-\CFA memory management extends allocation safety by implicitly honouring all alignment requirements, \eg in
-\begin{cfa}
-struct S { int i; } __attribute__(( aligned( 128 ) )); // cache-line alignment
-S * sp = malloc();                                                              §\C{// honour type alignment}§
-\end{cfa}
-the storage allocation is implicitly aligned to 128 rather than the default 16.
-The alignment check is performed at compile time so there is no runtime cost.
-
-\CFA memory management extends the resize capability with the notion of \newterm{sticky properties}.
-Hence, initial allocation capabilities are remembered and maintained when resize requires copying.
-For example, an initial alignment and fill capability are preserved during a resize copy so the copy has the same alignment and extended storage is filled.
-Without sticky properties it is dangerous to use ©realloc©, resulting in an idiom of manually performing the reallocation to maintain correctness.
-\begin{cfa}
-
-\end{cfa}
-
-\CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
-\begin{cfa}
-struct S { int i; };                                                    §\C{// cache-line aglinment}§
-void ?{}( S & s, int i ) { s.i = i; }
-// assume ?|? operator for printing an S
-
-S & sp = *®new®( 3 );                                                   §\C{// call constructor after allocation}§
-sout | sp.i;
-®delete®( &sp );
-
-S * spa = ®anew®( 10, 5 );                                              §\C{// allocate array and initialize each array element}§
-for ( i; 10 ) sout | spa[i] | nonl;
-sout | nl;
-®adelete®( 10, spa );
-\end{cfa}
-Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
-Note, the matching deallocation routines ©delete©/©adelete©.
+\end{center}
+It is impossible to resize with alignment because the underlying ©realloc© allocates storage if more space is needed, and it does not honour alignment from the original allocation.
 
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+// C unsafe allocation
 extern "C" {
-        // C unsafe allocation
-        void * malloc( size_t size );§\indexc{malloc}§
-        void * calloc( size_t dim, size_t size );§\indexc{calloc}§
-        void * realloc( void * ptr, size_t size );§\indexc{realloc}§
-        void * memalign( size_t align, size_t size );§\indexc{memalign}§
-        void * aligned_alloc( size_t align, size_t size );§\indexc{aligned_alloc}§
-        int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
-        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize );§\indexc{cmemalign}§ // CFA
-
-        // C unsafe initialization/copy
-        void * memset( void * dest, int c, size_t size );§\indexc{memset}§
-        void * memcpy( void * dest, const void * src, size_t size );§\indexc{memcpy}§
-}
-
-void * realloc( void * oaddr, size_t nalign, size_t size ); // CFA heap
+void * malloc( size_t size );§\indexc{memset}§
+void * calloc( size_t dim, size_t size );§\indexc{calloc}§
+void * realloc( void * ptr, size_t size );§\indexc{realloc}§
+void * memalign( size_t align, size_t size );§\indexc{memalign}§
+int posix_memalign( void ** ptr, size_t align, size_t size );§\indexc{posix_memalign}§
+
+// C unsafe initialization/copy
+void * memset( void * dest, int c, size_t size );
+void * memcpy( void * dest, const void * src, size_t size );
+}
 
 forall( dtype T | sized(T) ) {
-        // §\CFA§ safe equivalents, i.e., implicit size specification
+// §\CFA§ safe equivalents, i.e., implicit size specification
         T * malloc( void );
         T * calloc( size_t dim );
         T * realloc( T * ptr, size_t size );
         T * memalign( size_t align );
-        T * cmemalign( size_t align, size_t dim  );
         T * aligned_alloc( size_t align );
         int posix_memalign( T ** ptr, size_t align );
 
-        // §\CFA§ safe general allocation, fill, resize, alignment, array
-        T * alloc( void );§\indexc{alloc}§                                      §\C[3.5in]{// variable, T size}§
-        T * alloc( size_t dim );                                                        §\C{// array[dim], T size elements}§
-        T * alloc( T ptr[], size_t dim );                                       §\C{// realloc array[dim], T size elements}§
-
-        T * alloc_set( char fill );§\indexc{alloc_set}§         §\C{// variable, T size, fill bytes with value}§
-        T * alloc_set( T fill );                                                        §\C{// variable, T size, fill with value}§
-        T * alloc_set( size_t dim, char fill );                         §\C{// array[dim], T size elements, fill bytes with value}§
-        T * alloc_set( size_t dim, T fill );                            §\C{// array[dim], T size elements, fill elements with value}§
-        T * alloc_set( size_t dim, const T fill[] );            §\C{// array[dim], T size elements, fill elements with array}§
-        T * alloc_set( T ptr[], size_t dim, char fill );        §\C{// realloc array[dim], T size elements, fill bytes with value}§
-
-        T * alloc_align( size_t align );                                        §\C{// aligned variable, T size}§
-        T * alloc_align( size_t align, size_t dim );            §\C{// aligned array[dim], T size elements}§
-        T * alloc_align( T ptr[], size_t align );                       §\C{// realloc new aligned array}§
-        T * alloc_align( T ptr[], size_t align, size_t dim ); §\C{// realloc new aligned array[dim]}§
-
-        T * alloc_align_set( size_t align, char fill );         §\C{// aligned variable, T size, fill bytes with value}§
-        T * alloc_align_set( size_t align, T fill );            §\C{// aligned variable, T size, fill with value}§
-        T * alloc_align_set( size_t align, size_t dim, char fill ); §\C{// aligned array[dim], T size elements, fill bytes with value}§
-        T * alloc_align_set( size_t align, size_t dim, T fill ); §\C{// aligned array[dim], T size elements, fill elements with value}§
-        T * alloc_align_set( size_t align, size_t dim, const T fill[] ); §\C{// aligned array[dim], T size elements, fill elements with array}§
-        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}§
-
-        // §\CFA§ safe initialization/copy, i.e., implicit size specification
-        T * memset( T * dest, char fill );§\indexc{memset}§
+// §\CFA§ safe general allocation, fill, resize, array
+        T * alloc( void );§\indexc{alloc}§
+        T * alloc( char fill );
+        T * alloc( size_t dim );
+        T * alloc( size_t dim, char fill );
+        T * alloc( T ptr[], size_t dim );
+        T * alloc( T ptr[], size_t dim, char fill );
+
+// §\CFA§ safe general allocation, align, fill, array
+        T * align_alloc( size_t align );
+        T * align_alloc( size_t align, char fill );
+        T * align_alloc( size_t align, size_t dim );
+        T * align_alloc( size_t align, size_t dim, char fill );
+
+// §\CFA§ safe initialization/copy, i.e., implicit size specification
+        T * memset( T * dest, char c );§\indexc{memset}§
         T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
 
-        // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types
-        T * amemset( T dest[], char fill, size_t dim );
+// §\CFA§ safe initialization/copy array
+        T * amemset( T dest[], char c, size_t dim );
         T * amemcpy( T dest[], const T src[], size_t dim );
 }
 
-// §\CFA§ allocation/deallocation and constructor/destructor, non-array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );§\indexc{new}§
-forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );§\indexc{delete}§
-forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
+// §\CFA§ allocation/deallocation and constructor/destructor
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§
+forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§
+forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
   void delete( T * ptr, Params rest );
 
-// §\CFA§ allocation/deallocation and constructor/destructor, array types
-forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
-forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
-forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
+// §\CFA§ allocation/deallocation and constructor/destructor, array
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
+forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
   void adelete( size_t dim, T arr[], Params rest );
 \end{cfa}