Changeset 2c2e865 for doc

Timestamp:

Mar 20, 2026, 8:23:59 AM (33 hours ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

c6d65a1

Parents:

5c56a22

Message:

update user documentation on AST dump flags, and turn off silent in Makefile

Location:

doc/user

Files:

• Makefile (modified) (1 diff)
• user.tex (modified) (23 diffs)

doc/user/Makefile

@@ -9 +9 @@
 BibTeX = BIBINPUTS=${BibDir}: && export BIBINPUTS && bibtex
 
-MAKEFLAGS = --no-print-directory --silent #
+MAKEFLAGS = --no-print-directory # --silent
 VPATH = ${Build} ${Figures}
 

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Wed Sep 17 09:15:48 2025
-%% Update Count     : 7251
+%% Last Modified On : Fri Mar 20 08:05:59 2026
+%% Update Count     : 7399
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -153 +153 @@
 % Any language feature that is not described here can be assumed to be using the standard \Celeven syntax.
 \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.
-Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
+Like C, \CFA is a statically typed, procedural (non-\Index{object-oriented}) language with a low-overhead runtime, meaning there is \Index{managed memory} (no global \Index{garbage-collection}, but \Index{regional garbage-collection}\index{garbage-collection!regional} is possible.
 The primary new features include polymorphic routines and types, exceptions, concurrency, and modules.
 
 One of the main design philosophies of \CFA is to ``\Index{describe not prescribe}'', which means \CFA tries to provide a pathway from low-level C programming to high-level \CFA programming, but it does not force programmers to ``do the right thing''.
+There is no notion or requirement of \emph{rewriting} a legacy C program to \CFA.
 Programmers can cautiously add \CFA extensions to their C programs in any order and at any time to incrementally move towards safer, higher-level programming.
-A programmer is always free to reach back to C from \CFA, for any reason, and in many cases, new \CFA features can be locally switched back to their C counterpart.
-There is no notion or requirement for \emph{rewriting} a legacy C program to \CFA;
-instead, a programmer evolves a legacy program into \CFA by incrementally incorporating \CFA features.
-As well, new programs can be written in \CFA using a combination of C and \CFA features.
 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.
 
@@ -211 +208 @@
 The manual does not teach programming, \ie how to combine the new constructs to build complex programs.
 The reader must have an intermediate knowledge of control flow, data structures, and concurrency issues to understand the ideas presented, as well as some experience programming in C/\CC.
-Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
+% Implementers should refer to the \CFA Programming Language Specification for details about the language syntax and semantics.
 Changes to the syntax and additional features are expected to be included in later revisions.
 
@@ -321 +318 @@
 \end{comment}
 
-However, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing, as for \CC.
+As for \CC, it is necessary to differentiate between C and \CFA code because of name \Index{overload}ing.
 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 these routines into one overloaded name ©abs©:
@@ -338 +335 @@
 The problem is a \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).
 Overloaded names must use \newterm{name mangling}\index{mangling!name} to create unique names that are different from unmangled C names.
-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.
+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.
 The only way around this problem is C's approach of creating unique names for each pairing of operation and type.
 
@@ -349 +346 @@
 \section{\CFA Compilation}
 
-\CFA is a \newterm{transpiler}, meaning it reads in a programming language (\CFA) as input and generates another programming language (C) as output, whereas a \newterm{compiler} reads in a programming language and generates assembler/machine code.
-Hence, \CFA is like the C preprocessor modifying a program and sending it on to another step for further transformation.
+\CFA is currently a \newterm{transpiler}, meaning it reads in a programming language (\CFA) as input and generates another programming language (C) as output, whereas a \newterm{compiler} reads in a programming language and generates assembler/machine code.
+Hence, \CFA is like the C preprocessor modifying a program and sending it onto another step for further transformation.
 The order of transformation is C preprocessor, \CFA, and finally GNU C compiler, which also has a number of transformation steps, such as assembler and linker.
 
@@ -359 +356 @@
 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.
 
-\CFA has the following ©gcc© flags turned on:
-\begin{description}[topsep=0pt]
+\CFA turns on the following ©gcc© flags.
+\begin{description}
 \item
 \Indexc{-std=gnu11}\index{compilation option!-std=gnu11@{©-std=gnu11©}}
@@ -366 +363 @@
 \end{description}
 
-\CFA has the following new options:
-\begin{description}[topsep=0pt]
+\CFA adds the following new flags, where prefixing with ©"no"© negates the meaning of the flag.
+\begin{description}[leftmargin=*,itemsep=0pt]
+\item
+\Indexc{-help}\index{compilation option!-help@©-help©}
+Information about the set of \CFA compilation flags is printed.
+
+\item
+\Indexc{-nohelp}\index{compilation option!-nohelp@©-nohelp©}
+Information about the set of \CFA compilation flags is not printed.
+\textbf{This option is the default.}
+
 \item
 \Indexc{-CFA}\index{compilation option!-CFA@©-CFA©}
@@ -387 +393 @@
 \Indexc{-nodebug}\index{compilation option!-nodebug@©-nodebug©}
 The program is linked with the non-debugging version of the runtime system, so the execution of the program is faster.
-\Emph{However, no runtime checks or ©assert©s are performed so errors usually result in abnormal program behaviour or termination.}
-
-\item
-\Indexc{-help}\index{compilation option!-help@©-help©}
-Information about the set of \CFA compilation flags is printed.
-
-\item
-\Indexc{-nohelp}\index{compilation option!-nohelp@©-nohelp©}
-Information about the set of \CFA compilation flags is not printed.
-\textbf{This option is the default.}
 
 \item
@@ -457 +453 @@
 \end{lstlisting}
 Alternatively, multiple flags can be specified separated with commas and \emph{without} spaces.
-\begin{lstlisting}[language=sh,{moredelim=**[is][\protect\color{red}]{®}{®}}]
+\begin{lstlisting}[language=sh,escapechar=§,{moredelim=**[is][\protect\color{red}]{®}{®}}]
 cfa §test§.cfa -XCFA®,®-Pparse®,®-n # show program parse without prelude
 \end{lstlisting}
@@ -504 +500 @@
 \item
 \Indexc{excpdecl}\index{transpiler option!-P@{©-P©}!©excpdecl©}\index{transpiler option!--print@{©-print©}!©excpdecl©} \, print AST after translating exception decls
-\item
-\Indexc{symevt}\index{transpiler option!-P@{©-P©}!©symevt©}\index{transpiler option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
-\item
-\Indexc{expralt}\index{transpiler option!-P@{©-P©}!©expralt©}\index{transpiler option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
-\item
-\Indexc{valdecl}\index{transpiler option!-P@{©-P©}!©valdecl©}\index{transpiler option!--print@{©-print©}!©valdecl©} \, print AST after declaration validation pass
+% \item
+% \Indexc{symevt}\index{transpiler option!-P@{©-P©}!©symevt©}\index{transpiler option!--print@{©-print©}!©symevt©} \, print AST after symbol table events
+% \item
+% \Indexc{expralt}\index{transpiler option!-P@{©-P©}!©expralt©}\index{transpiler option!--print@{©-print©}!©expralt©} \, print AST after expressions alternatives
+\item
+\Indexc{validecl}\index{transpiler option!-P@{©-P©}!©validecl©}\index{transpiler option!--print@{©-print©}!©validecl©} \, print AST after declaration validation pass
 \item
 \Indexc{bresolver}\index{transpiler option!-P@{©-P©}!©bresolver©}\index{transpiler option!--print@{©-print©}!©bresolver©} \, print AST before resolver step
 \item
-\Indexc{expranly}\index{transpiler option!-P@{©-P©}!©expranly©}\index{transpiler option!--print@{©-print©}!©expranly©} \, print AST after expression analysis
+\Indexc{expranl}\index{transpiler option!-P@{©-P©}!©expranl©}\index{transpiler option!--print@{©-print©}!©expranl©} \, print AST after expression analysis
 \item
 \Indexc{ctordtor}\index{transpiler option!-P@{©-P©}!©ctordtor©}\index{transpiler option!--print@{©-print©}!©ctordtor©} \, print AST after ctor/dtor are replaced
@@ -605 +601 @@
 Exponentiation, $x^y$, means raise $x$ to the $y$th power.
 When $y$ is a positive integer, exponentiation corresponds to $\prod_{i=1}^{y} x$.
-
 C, \CC, Java and other programming languages have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, using a routine like \Indexc{pow( x, y )} instead.
 Ada, Haskell, Python and other programming languages have an exponentiation operator often using operators ©^© or ©**©.
@@ -645 +640 @@
 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
 
-The \Indexc{if} and \Indexc{while} expressions are extended with declarations, similar to the \Indexc{for} declaration expression.\footnote{
-Declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.}
+The \Indexc{if} and \Indexc{while} expressions are extended with declarations, similar to the \Indexc{for} declaration expression.
+Note, declarations in the \Indexc{do}-©while© condition are not useful because they appear after the loop body.
 \begin{cfa}
 if ( ®int x = f()® ) ...                        §\C[2.75in]{// x != 0}§
@@ -755 +750 @@
 
 C allows a number of questionable forms for the \Indexc{switch} statement:
-\begin{enumerate}
+\begin{enumerate}[leftmargin=*]
 \item
 By default, the end of a \Indexc{case} clause\footnote{
@@ -881 +876 @@
 The key observation is that the ©switch© statement branches into a control structure, \ie there are multiple entry points into its statement body.
 \end{enumerate}
-
 Before discussing language changes to deal with these problems, it is worth observing that in a typical C program:
 \begin{itemize}
@@ -893 +887 @@
 and there is only a medium amount of fall-through from one ©case© clause to the next, and most of these result from a list of case values executing common code, rather than a sequence of case actions that compound.
 \end{itemize}
+
 These observations put into perspective the \CFA changes to the ©switch© statement.
-\begin{enumerate}
+\begin{enumerate}[leftmargin=*]
 \item
 Eliminating default fall-through has the greatest potential for affecting existing code.
@@ -1015 +1010 @@
 To simplify creating an infinite loop, the \Indexc{for}, \Indexc{while}, and \Indexc{do} loop-predicate\index{loop predicate} is extended with an empty conditional, meaning a comparison value of ©1© (true).
 \begin{cfa}
-while ( )                               §\C{// while ( true )}§
-for ( )                                 §\C{// for ( ; true; )}§
-do ... while ( )                §\C{// do ... while ( true )}§
-\end{cfa}
-
-Looping a predefined number of times, possibly with a loop index, occurs frequently.
-The ©for© control\index{for control}, \ie ©for ( /* control */ )©, is extended with a range and step.
-A range is a set of values defined by an optional low value (default to 0), tilde, and high value, ©L ~ H©, with an optional step ©~ S© (default to 1), which means an ascending set of values from ©L© to ©H© in positive steps of ©S©.
-\begin{cfa}
-0 ~ 5                                                                   §\C{// \{ 0, 1, 2, 3, 4, 5 \}}§
--8 ~ -2 ~ 2                                                             §\C{// \{ -8. -6, -4, -2 \}}§
--3 ~ 3 ~ 1                                                              §\C{// \{ -3, -2, -1, 0, 1, 2, 3 \}}§
-\end{cfa}
-\R{Warning}: A range in descending order, \eg ©5 ~ -3© is the null (empty) set, \ie no values in the set.
-As well, a ©0© or negative step is undefined.
-
-The range character, ©'~'©, is decorated on the left and right to control how the set values are presented in the loop body.
-The range character can be prefixed with ©'+'© or ©'-'© indicating the \emph{direction} the range is scanned, \ie from left to right (ascending) or right to left (descending).
-Ascending uses operator \Indexc{+=};
-descending uses operator \Indexc{-=}.
-If there is no prefix character, it defaults to ©'+'©.
-\begin{cfa}
--8 ®§\Sp§®~ -2                                                  §\C{// ascending, no prefix}§
-0 ®+®~ 5                                                                §\C{// ascending, prefix}§
--3 ®-®~ 3                                                               §\C{// descending, prefix}§
-\end{cfa}
-For descending iteration, the ©L© and ©H© values are \emph{implicitly} switched, and the increment/decrement for ©S© is toggled.
-Hence, the order of values in a set may not be the order the values are presented during looping.
-Changing the iteration direction is faster and safer because the direction prefix can be added/removed without changing existing (correct) range information.
-\R{Warning}: reversing the range endpoints for descending order results in an empty set.
-\begin{cfa}
-for ( i; ®10 -~ 1® )                                    §{\C{// WRONG descending range!}§
-\end{cfa}
-
-Because C uses zero origin, most loops iterate from 0 to $N - 1$.
-Hence, when scanning a range during iteration, the last value is dropped, \eg ©0 ~ 5© is ©0, 1, 2, 3, 4©, an exclusive range, [©L©,©H©\R{)}.
-To obtain \emph{all} the values in the range, the range character is postfixed with ©'='©, \eg ©0 ~= 5© is ©0, 1, 2, 3, 4, 5©, an inclusive range, [©L©,©H©\R{]}.
-\index{\~}\index{ascending exclusive range}
-\index{\~=}\index{ascending inclusive range}
-\index{-\~}\index{descending exclusive range}
-\index{-\~=}\index{descending inclusive range}
-
-\begin{comment}
-To simplify loop iteration a range is provided, from low to high, and a traversal direction, ascending (©+©) or descending (©-©).
-The following is the syntax for the loop range, where ©[©\,©]© means optional.
-\begin{cfa}[deletekeywords=default]
-[ ®index ;® ] [ [ ®min® (default 0) ] [ direction ®+®/®-® (default +) ] ®~® [ ®=® (include endpoint) ] ] ®max® [ ®~ increment® ]
-\end{cfa}
-For ©=©, the range includes the endpoint (©max©/©min©) depending on the direction (©+©/©-©).
-\end{comment}
-
-©for© control is formalized by the following regular expression:
+while ( )                                                               §\C{// while ( true )}§
+for ( )                                                                 §\C{// for ( ; true; )}§
+do ... while ( )                                                §\C{// do ... while ( true )}§
+\end{cfa}
+
+The ©for© loop is the primary mechanism for iterating a predefined number of times.
+The basic C ©for© loop requires multiple parts, even though most are unnecessary, \eg interating 5 times provides multiple places for errors.
+\begin{cfa}
+for ( ®int i = 0; i < 5; i += 1® ) ...
+\end{cfa}
+\CFA simplifies the ©for©-control\index{for control} by defining an integral set of values and specifying if the set is traversed forward or backward.
+A range is a set of values defined by an optional low value (0 default) and high value, with an optional step ©S© (1 default) seperated by tildes, ©[L ~] H [~ S]©, where ©[©\,©]© implies optional.
+For example, the set ©0 ~ 5 ~ 1© is the set of values 0, 1, 2, 3, 4, 5, which can be travered either direction.
+Hence, iterating 5 times can be written succinctly as:
+\begin{cfa}
+for ( 5 ) ...                                                   §\C{// 0 \textasciitilde\ 5 \textasciitilde\ 1}§
+for ( 0 ~ 5 ) ...                                               §\C{// 0 \textasciitilde\ 5 \textasciitilde\ 1}§
+for ( 0 ~ 5 ~ 1 ) ...                                   §\C{// 0 \textasciitilde\ 5 \textasciitilde\ 1}§
+\end{cfa}
+To indicate the scanned direction, the middle tilde is prefixed with ©'+'© or ©'-'©, for forward or backwards, respectively;
+no prefix character, defaults to ©'+'©, as above.
+\begin{cfa}
+for ( ®+®~ 5 ) ...                                              §\C{// forward}§
+for ( ®-®~ 5 ) ...                                              §\C{// backward}§
+for ( 0 ®+®~ 5 ) ...                                    §\C{// forward}§
+for ( 0 ®-®~ 5 ) ...                                    §\C{// backward}§
+for ( 0 ®+®~ 5 ~ 1 ) ...                                §\C{// forward}§
+for ( 0 ®-®~ 5 ~ 1 ) ...                                §\C{// backward}§
+\end{cfa}
+\R{Warning}: the expression ©~5© (no prefix), has a preexisting meaning in C: complement the bits of ©5©, means ©for ( -6 )©, as ©-6© is the complement of ©5©.
+This anomaly is unlikely to cause problems because programers should write the shorter ©for ( 5 )©.
+Hence, for descending iteration, the ©L© and ©H© values are \emph{implicitly} switched, and the increment/decrement for ©S© is toggled from add to subtract.
+Using a direction prefix rather than switching the low and high values is faster and safer because the prefix is added/removed without changing existing (correct) range information.
+A consequence of of the direction prefix is that the range, \eg ©5 ~ 0© is the null (empty) set, as there are no values in the range ©5© to ©0©.
+As well, a ©0© or negative step generates an infinite or large range (finite integers), as it does in C.
+\begin{cfa}
+-3 ~ 3 ~ ®0®                                                    §\C{// infinite: -3, -3, -3, ... }§
+-3 ~ 3 ~ ®-1®                                                   §\C{// large: -3, -4, -5, ..., 2, 3}§
+-3 -~ 3 ~ ®-1®                                                  §\C{// large: 3, 4, 5, ..., -2, -3}§
+\end{cfa}
+Finally, C uses zero origin, so most loops iterate from 0 to $N - 1$.
+To match this idiom, a range used for iteration, drops the last value, \eg ©0 ~ 5© is actually ©0, 1, 2, 3, 4©, \ie an exclusive range, [©L©,©H©\R{)}.
+To obtain the inclusive range, [©L©,©H©\R{]}, the middle titlde is postfixed with ©'='©, \eg ©0 ~= 5© is ©0, 1, 2, 3, 4, 5©.
+\index{\~}\index{ascending exclusive range}%
+\index{\~=}\index{ascending inclusive range}%
+\index{-\~}\index{descending exclusive range}%
+\index{-\~=}\index{descending inclusive range}%
+The following is the complete regular expression for ©for©-control:
 \begin{cquote}
 [ ©L© ]\ \ [ ©+©\ \ |\ \ ©-© ]\ \ \R{©~©}\ \ [ ©=© ]\ \ ©H©\ \ [ ©~© ©S© ]
 \end{cquote}
 where ©[©\,©]© denotes optional and ©|© denotes alternative.
-That is, the optional low set value, the optional scan direction (ascending/descending), the (possibly) required range character, the optional include last-scan value, the required high set value, and the optional range character and step value.
-\R{Warning}: the regular expression allows the form ©~H©, but this syntax has a preexisting meaning in C: complement the bits of ©H©, \eg ©for ( ~5 )© meaning ©for ( -6 )©, as ©-6© is the complement of ©5©.
-This anomaly is unlikely to cause problems because programers should write the shorter ©for ( 5 )©.
-
-The previous ©for© loops have an anonymous loop index in which the range iteration is computed.
-To access the value of the range iteration in the loop body, a \Index{loop index} is specified before the range.
-\begin{cfa}
-for ( ®int i;® 0 ~ 10 ~ 2 ) { ... ®i® ... }     §\C{// loop index available in loop body}§
-\end{cfa}
-Hence, unlike the 3 components in the C ©for©-control, there are only two components in the \CFA ©for©-control: the optional index variable and the range.
-The index type is optional (like \CC ©auto©), where the type is normally inferred from the low value ©L© because it initializes the index (the type of ©H© can be different from ©L©).
-When ©L© is omitted, the type of the required high value ©H© is used, as both ©L© and ©H© are the same type in this case.
+%That is, the optional low set value, the optional scan direction (ascending/descending), the (possibly) required range character, the optional include last-scan value, the required high set value, and the optional range character and step value.
+
+To add a \Index{loop index}, the ©for©-control is prefixed with a variable or variable declaration.
+\begin{cfa}
+for ( ®i;® ®0L® ~ 10 ~ 2 ) { ... ®i® ... }      §\C{// implicitly typed index, typeof(0L) is long int}§
+for ( ®long int i;® 0 ~ 10 ~ 2 ) { ... ®i® ... } §\C{// explicitly typed index}§
+\end{cfa}
+Hence, there are only two components in the \CFA ©for©-control \vs 3 in C.
+If the index is untyped, it is inferred from the low value ©L© because it initializes the index (the type of ©H© can be different from ©L©).
+When ©L© is omitted, the type of ©H© is used, as both ©L© and ©H© are the same type in this case.
 \begin{cfa}
 for ( i; ®1.5® ~ 5 )                                    §\C{// typeof(1.5) i; 1.5 is low value}§
 for ( i; ®5.5® )                                                §\C{// typeof(5.5) i; 5.5 is high value}§
 \end{cfa}
-
+This semantics is the same as \CC ©auto© for declaring the loop index.
+\begin{C++}
+for ( auto i = 0; i < 1.5; i += 5 )
+\end{C++}
+
+\begin{comment}
 The following examples illustrate common \CFA ©for©-control combinations, with the C counter-part in the comment.
 \begin{itemize}[itemsep=0pt]
@@ -1121 +1115 @@
 \end{cfa}
 \end{itemize}
-
-There are situations when the ©for©-control actions need to be moved into the loop body, \eg a mid-loop exit does not need an iteration-completion test in the ©for© control.
-The character ©'@'© indicates that a specific ©for©-control action is ignored, \ie generates no code.
+\end{comment}
+
+There are also situations when the ©for©-control actions need to be moved into the loop body, \eg a mid-loop exit does not need an iteration-completion test in the ©for©-control.
+The character ©'@'© indicates a specific ©for©-control action is elided, \ie generates no code.
 \begin{cfa}
 for ( i; ®@® -~ 10 )                                    §\C{// for ( typeof(10) i = 10; \R{/*empty*/}; i -= 1 )}§
@@ -1131 +1126 @@
 \end{cfa}
 \R{Warning}: ©L© \emph{cannot} be elided for the ascending range, \lstinline{@ ~ 5}, nor ©H© for the descending range, \lstinline{1 -~ @}, as the loop index is uninitialized.
-\R{Warning}: ©H© \emph{cannot} be elided in an anonymous loop index, ©1 ~ @©, as there is no index to stop the loop.
+As well, ©H© \emph{cannot} be elided in an anonymous loop index, ©1 ~ @©, as there is no index to stop the loop.
 
 There are situations when multiple loop indexes are required.
-The character ©':'© means add another index, where any number of indices may be chained in a single ©for© control.
+The character ©':'© is used to add another index, where any number of indices may be chained in a single ©for©-control.
 \begin{cfa}
 for ( i; 5  ®:®  j; 2 ~ 12 ~ 3 )                §\C{// for ( typeof(i) i = 1, j = 2; \R{i < 5 \&\& j < 12}; i += 1, j += 3 )}§
@@ -1246 +1241 @@
 \end{figure}
 
-Finally, any type that satisfies the ©Iterate© trait can be used with ©for© control.
+Finally, any type that satisfies the ©Iterate© trait can be used with ©for©-control.
 \begin{cfa}
 forall( T ) trait Iterate {
@@ -1260 +1255 @@
 }
 \end{cfa}
-\VRef[Figure]{f:ForControlStructureType} shows an example of a structure using ©for© control.
+\VRef[Figure]{f:ForControlStructureType} shows an example of a structure using ©for©-control.
 Note, the use of ©(S){0}© when implicitly setting the loop-index type, because using 0 incorrect declares the index to ©int© rather than ©S©.
 
@@ -1490 +1485 @@
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
-Therefore, reducing aggregate qualification is a useful language design goal.
+Therefore, reducing aggregate qualification is a useful design goal.
 
 C partially addresses the problem by eliminating qualification for enumerated types and unnamed \emph{nested} aggregates, which open their scope into the containing aggregate.
@@ -1496 +1491 @@
 \begin{cfa}
 struct S {
-        struct §\R{\LstCommentStyle{/* unnamed */}}§  { int g,  h; } __attribute__(( aligned(64) ));
+        struct ®/* unnamed */® { int g,  h; } __attribute__(( aligned(64) ));
         int tag;
-        union §\R{\LstCommentStyle{/* unnamed */}}§  {
+        union ®/* unnamed */®  {
                 struct { char c1,  c2; } __attribute__(( aligned(128) ));
                 struct { int i1,  i2; };