Diff [bb8ea3011a8148746d8e28699f24b68eaa57a951:d6681823cf43689609e83bcc9077750fba1c262d] for / – Cforall

doc/LaTeXmacros/common.tex

-              rbb8ea30
+              rd668182
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat Apr  9 10:06:39 2016
 %% Update Count     : 1
+%% Last Modified On : Wed May  4 08:01:10 2016
+%% Update Count     : 54
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 % Names used in the document.
 \newcommand{\CFA}{C$\mathbf\forall$\xspace}                             % set language symbolic name
 \newcommand{\CFL}{Cforall\xspace}                                               % set language text name
+\newcommand{\CFA}{C$\mathbf\forall$\xspace}              % set language symbolic name
+\newcommand{\CFL}{Cforall\xspace}                        % set language text name
 \newcommand{\CC}{C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
 \def\c11{ISO/IEC C} % C11 name (cannot have numbers in latex command name)
 …
    \belowdisplayskip \abovedisplayskip
+}
 \usepackage{relsize}                                                                    % must be after change to small or selects old size
+\usepackage{relsize}                                    % must be after change to small or selects old size
 % reduce size of chapter/section titles
 …
     \vskip 50\p@
   }}
 \renewcommand\section{\@startsection{section}{1}{\z@}{-3.0ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\large\bfseries}}
 \renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
+\renewcommand\section{\@startsection{section}{1}{\z@}{-3.5ex \@plus -1ex \@minus -.2ex}{2.3ex \@plus .2ex}{\normalfont\large\bfseries}}
+\renewcommand\subsection{\@startsection{subsection}{2}{\z@}{-3.25ex \@plus -1ex \@minus -.2ex}{1.5ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
 \renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}{-2.5ex \@plus -1ex \@minus -.2ex}{1.0ex \@plus .2ex}{\normalfont\normalsize\bfseries}}
 \renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}{-2.0ex \@plus -1ex \@minus -.2ex}{-1em}{\normalfont\normalsize\bfseries}}
 …
 \newcommand{\@sIndex}[2][\@empty]{#2\ifx#1\@empty\index{#2}\else\index{#1@{\protect#2}}\fi}
+\newcommand{\Indexc}[1]{\lstinline$#1$\index{#1@\lstinline$#1$}}
+\newcommand{\indexc}[1]{\index{#1@\lstinline$#1$}}
 \newcommand{\newtermFontInline}{\emph}
 \newcommand{\newterm}{\@ifstar\@snewterm\@newterm}
 …
 % blocks and titles
 \newcommand{\define}[1]{\emph{#1\/}\index{#1}}
-\newcommand{\rewrite}{\(\Rightarrow\)}
 \newcommand{\rewriterules}{\paragraph{Rewrite Rules}~\par\noindent}
 \newcommand{\examples}{\paragraph{Examples}~\par\noindent}
 …
 \newcommand{\lhs}[1]{\par{\emph{#1:}}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\rhs}{\hfil\break\hbox{\hskip1in}}
 \newcommand{\oldlhs}[1]{\emph{#1: \ldots}\index{#1@{\emph{#1}}|italic}}
+\newcommand{\oldlhs}[1]{\emph{#1: \dots}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\nonterm}[1]{\emph{#1\/}\index{#1@{\emph{#1}}|italic}}
 \newcommand{\opt}{$_{opt}$\ }
 …
                 fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,otype,restrict,_Static_assert,
                 _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,},
-        moredelim=**[is][\color{red}]{`}{`}, % red highlighting of program text
 }%
 …
 columns=flexible,
 basicstyle=\sf\relsize{-1},
+stringstyle=\tt,
 tabsize=4,
 xleftmargin=\parindent,
+escapechar=@,
+extendedchars=true,
+escapechar=§,
 mathescape=true,
 keepspaces=true,
 showstringspaces=false,
 showlines=true,
+aboveskip=6pt,
+belowskip=4pt,
+literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used for red highlighting
+aboveskip=4pt,
+belowskip=2pt,
+moredelim=**[is][\color{red}]{®}{®}, % red highlighting
+% moredelim=**[is][\color{blue}]{¢}{¢}, % blue highlighting
+moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % temporarily turn off keywords
+% literate={\\`}{\raisebox{0.3ex}{\ttfamily\upshape \hspace*{-2pt}`}}1, % escape \`, otherwise used for red highlighting
+literate={...}{{$\dots$}}1 {<-}{{$\leftarrow$}}1 {=>}{{$\Rightarrow$}}1,
 }%
+\lstMakeShortInline©    % single-character for \lstinline
 \makeatletter
 …
 \lst@ProcessOther{"22}{\lst@ttfamily{"}{\raisebox{0.3ex}{\ttfamily\upshape "}}} % replace double quote
 \lst@ProcessOther{"27}{\lst@ttfamily{'}{\raisebox{0.3ex}{\ttfamily\upshape '\hspace*{-2pt}}}} % replace single quote
 \lst@ProcessOther{"2D}{\lst@ttfamily{-}{\ttfamily\upshape -}} % replace minus
 \lst@ProcessOther{"3C}{\lst@ttfamily{<}{\texttt{<}}} % replace less than
 \lst@ProcessOther{"3E}{\lst@ttfamily{<}{\texttt{>}}} % replace greater than
+\lst@ProcessOther{"2D}{\lst@ttfamily{-}{\textbf{\texttt{-}}}} % replace minus
+\lst@ProcessOther{"3C}{\lst@ttfamily{<}{\textbf{\texttt{<}}}} % replace less than
+\lst@ProcessOther{"3E}{\lst@ttfamily{>}{\textbf{\texttt{>}}}} % replace greater than
 \lst@ProcessOther{"5E}{\raisebox{0.4ex}{$\scriptstyle\land\,$}} % replace circumflex
 \lst@ProcessOther{"5F}{\lst@ttfamily{\char95}{{\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}}} % replace underscore

doc/refrat/refrat.tex

-              rbb8ea30
+              rd668182
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -*- Mode: Latex -*- %%%%%%%%%%%%%%%%%%%%%%%%%%%%``%%
 %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 %%
 …
 %% Created On       : Wed Apr  6 14:52:25 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat Apr  9 10:19:12 2016
 %% Update Count     : 8
+%% Last Modified On : Tue May  3 18:00:28 2016
+%% Update Count     : 64
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
+% inline code ©...© (copyright 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[openright,twoside]{report}
 …
 % Latex packages used in the document.
+\usepackage[T1]{fontenc}                                % allow Latin1 (extended ASCII) characters
+\usepackage{textcomp}
+\usepackage[latin1]{inputenc}
+\usepackage{upquote}
 \usepackage{fullpage,times}
+\usepackage{epic,eepic}
 \usepackage{xspace}
 \usepackage{varioref}
 …
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Names used in the document.
+\newcommand{\Version}{1.0.0}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \setcounter{secnumdepth}{3}                             % number subsubsections
 \setcounter{tocdepth}{3}                                % subsubsections in table of contents
 …
 \subsection{Scopes of identifiers}\index{scopes}
+\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same
+\Index{name space}, instead of hiding them.
+The outer declaration is hidden if the two declarations have \Index{compatible type}, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type, or if one declaration is a \lstinline$type$\use{type} or
+\lstinline$typedef$\use{typedef} declaration and the other is not.  The outer declaration becomes
+\Index{visible} when the scope of the inner declaration terminates.
+\begin{rationale}
+Hence, a \CFA program can declare an \lstinline$int v$ and a \lstinline$float v$ in the same scope;
+\CFA's scope rules differ from C's in one major respect: a declaration of an identifier may overload\index{overloading} outer declarations of lexically identical identifiers in the same \Index{name space}, instead of hiding them.
+The outer declaration is hidden if the two declarations have \Index{compatible type}, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type, or if one declaration is a ©type©\use{type} or ©typedef©\use{typedef} declaration and the other is not.
+The outer declaration becomes \Index{visible} when the scope of the inner declaration terminates.
+\begin{rationale}
+Hence, a \CFA program can declare an ©int v© and a ©float v© in the same scope;
 a {\CC} program can not.
 \end{rationale}
 …
 \CFA's linkage rules differ from C's in only one respect: instances of a particular identifier with external or internal linkage do not necessarily denote the same object or function.
+Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have
+\Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
+Instead, in the set of translation units and libraries that constitutes an entire program, any two instances of a particular identifier with \Index{external linkage} denote the same object or function if they have \Index{compatible type}s, or if one declares an array type and the other declares a pointer type and the element type and pointed-at type are compatible, or if one has function type and the other is a pointer to a compatible function type.
 Within one translation unit, each instance of an identifier with \Index{internal linkage} denotes the same object or function in the same circumstances.
 Identifiers with \Index{no linkage} always denote unique entities.
 \begin{rationale}
 A \CFA program can declare an \lstinline$extern int v$ and an \lstinline$extern float v$;
+A \CFA program can declare an ©extern int v© and an ©extern float v©;
 a C program cannot.
 \end{rationale}
 …
 \end{lstlisting}
 The type parameters in an instantiation of a generic type must satisfy any constraints in the forall specifier on the type generator declaration, e.g., \lstinline$sumable$.
+The type parameters in an instantiation of a generic type must satisfy any constraints in the forall specifier on the type generator declaration, e.g., ©sumable©.
 The instantiation then has the semantics that would result if the type parameters were substituted into the type generator declaration by macro substitution.
 …
 \CFA defines situations where values of one type are automatically converted to another type.
 These conversions are called \define{implicit conversion}s.
+The programmer can request
+\define{explicit conversion}s using cast expressions.
+The programmer can request \define{explicit conversion}s using cast expressions.
 …
 In \CFA, these conversions play a role in overload resolution, and collectively are called the \define{safe arithmetic conversion}s.
 Let \(int_r\) and \(unsigned_r\) be the signed and unsigned integer types with integer conversion rank\index{integer conversion rank}\index{rank|see{integer conversion rank}} $r$.
 Let \(unsigned_{mr}\) be the unsigned integer type with maximal rank.
+Let ©int$_r$© and ©unsigned$_r$© be the signed and unsigned integer types with integer conversion rank\index{integer conversion rank}\index{rank|see{integer conversion rank}} $r$.
+Let ©unsigned$_{mr}$© be the unsigned integer type with maximal rank.
 The following conversions are \emph{direct} safe arithmetic conversions.
 …
 The \Index{integer promotion}s.
 \item
 For every rank $r$ greater than or equal to the rank of \lstinline$int$, conversion from \(int_r\) to \(unsigned_r\).
 \item
 For every rank $r$ greater than or equal to the rank of \lstinline$int$, where \(int_{r+1}\) exists and can represent all values of \(unsigned_r\), conversion from \(unsigned_r\) to \(int_{r+1}\).
 \item
 Conversion from \(unsigned_{mr}\) to \lstinline$float$.
+For every rank $r$ greater than or equal to the rank of ©int©, conversion from ©int$_r$© to ©unsigned$_r$©.
+\item
+For every rank $r$ greater than or equal to the rank of ©int©, where ©int$_{r+1}$© exists and can represent all values of ©unsigned$_r$©, conversion from ©unsigned$_r$© to ©int$_{r+1}$©.
+\item
+Conversion from ©unsigned$_{mr}$© to ©float©.
 \item
 Conversion from an enumerated type to its compatible integer type.
 \item
 Conversion from \lstinline$float$ to \lstinline$double$, and from \lstinline$double$ to \lstinline$long double$.
 \item
 Conversion from \lstinline$float _Complex$ to \lstinline$double _Complex$, and from \lstinline$double _Complex$ to \lstinline$long double _Complex$.
+Conversion from ©float© to ©double©, and from ©double© to ©long double©.
+\item
+Conversion from ©float _Complex© to ©double _Complex©, and from ©double _Complex© to ©long double _Complex©.
 \begin{sloppypar}
 \item
 Conversion from \lstinline$float _Imaginary$ to \lstinline$double _Imaginary$, and from \lstinline$double _Imaginary$ to \lstinline$long double$ \lstinline$_Imaginary$, if the implementation supports imaginary types.
+Conversion from ©float _Imaginary© to ©double _Imaginary©, and from ©double _Imaginary© to ©long double _Imaginary©, if the implementation supports imaginary types.
 \end{sloppypar}
 \end{itemize}
 If type \lstinline$T$ can be converted to type \lstinline$U$ by a safe direct arithmetic conversion and type \lstinline$U$ can be converted to type \lstinline$V$ by a safe arithmetic conversion, then the conversion from \lstinline$T$ to type \lstinline$V$ is an \emph{indirect} safe arithmetic conversion.
+If type ©T© can be converted to type ©U© by a safe direct arithmetic conversion and type ©U© can be converted to type ©V© by a safe arithmetic conversion, then the conversion from ©T© to type ©V© is an \emph{indirect} safe arithmetic conversion.
 \begin{rationale}
 …
 \label{anon-conv}
+If an expression's type is a pointer to a structure or union type that has a member that is an
+\Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
+If an expression's type is a pointer to a structure or union type that has a member that is an \Index{anonymous structure} or an \Index{anonymous union}, it can be implicitly converted\index{implicit conversion} to a pointer to the anonymous structure's or anonymous union's type.
 The result of the conversion is a pointer to the member.
 …
         int x, y;
 };
 void move_by( struct point * p1, struct point * p2 ) {@\impl{move_by}@
+void move_by( struct point * p1, struct point * p2 ) {§\impl{move_by}§
         p1->x += p2.x;
         p1->y += p2.y;
 …
 move_to( &cp1, &cp2 );
 \end{lstlisting}
+Thanks to implicit conversion, the two arguments that \lstinline$move_by()$ receives are pointers to
+\lstinline$cp1$'s second member and \lstinline$cp2$'s second member.
+Thanks to implicit conversion, the two arguments that ©move_by()© receives are pointers to ©cp1©'s second member and ©cp2©'s second member.
 …
 a direct safe arithmetic conversion;
 \item
 from any object type or incomplete type to \lstinline$void$;
 \item
 from a pointer to any non-\lstinline$void$ type to a pointer to \lstinline$void$;
+from any object type or incomplete type to ©void©;
+\item
+from a pointer to any non-©void© type to a pointer to ©void©;
 \item
 from a pointer to any type to a pointer to a more qualified version of the type\index{qualified type};
 …
 Conversions that are not safe conversions are \define{unsafe conversion}s.
 \begin{rationale}
 As in C, there is an implicit conversion from \lstinline$void *$ to any pointer type.
+As in C, there is an implicit conversion from ©void *© to any pointer type.
 This is clearly dangerous, and {\CC} does not have this implicit conversion.
 \CFA\index{deficiencies!void * conversion} keeps it, in the interest of remaining as pure a superset of C as possible, but discourages it by making it unsafe.
 …
 \begin{itemize}
 \item
+The cost of an implicit conversion from \lstinline$int$ to \lstinline$long$ is 1.
+The cost of an implicit conversion from \lstinline$long$ to \lstinline$double$ is 3, because it is defined in terms of conversions from \lstinline$long$ to \lstinline$unsigned long$, then to \lstinline$float$, and then to \lstinline$double$.
+\item
+If \lstinline$int$ can represent all the values of \lstinline$unsigned short$, then the cost of an implicit conversion from \lstinline$unsigned short$ to \lstinline$unsigned$ is 2:
+\lstinline$unsigned short$ to \lstinline$int$ to \lstinline$unsigned$.
+Otherwise, \lstinline$unsigned short$ is converted directly to \lstinline$unsigned$, and the cost is 1.
+\item
+If \lstinline$long$ can represent all the values of \lstinline$unsigned$, then the conversion cost of \lstinline$unsigned$ to \lstinline$long$ is 1.
+The cost of an implicit conversion from ©int© to ©long© is 1.
+The cost of an implicit conversion from ©long© to ©double© is 3, because it is defined in terms of conversions from ©long© to ©unsigned long©, then to ©float©, and then to ©double©.
+\item
+If ©int© can represent all the values of ©unsigned short©, then the cost of an implicit conversion from ©unsigned short© to ©unsigned© is 2: ©unsigned short© to ©int© to ©unsigned©.
+Otherwise, ©unsigned short© is converted directly to ©unsigned©, and the cost is 1.
+\item
+If ©long© can represent all the values of ©unsigned©, then the conversion cost of ©unsigned© to ©long© is 1.
 Otherwise, the conversion is an unsafe conversion, and its conversion cost is undefined.
 \end{itemize}
 …
 \begin{syntax}
 \oldlhs{keyword}
         \rhs \lstinline$forall$
         \rhs \lstinline$lvalue$
         \rhs \lstinline$trait$
         \rhs \lstinline$dtype$
         \rhs \lstinline$ftype$
         \rhs \lstinline$type$
+        \rhs ©forall©
+        \rhs ©lvalue©
+        \rhs ©trait©
+        \rhs ©dtype©
+        \rhs ©ftype©
+        \rhs ©otype©
 \end{syntax}
 …
 \CFA allows operator \Index{overloading} by associating operators with special function identifiers.
 Furthermore, the constants ``\lstinline$0$'' and ``\lstinline$1$'' have special status for many of C's data types (and for many programmer-defined data types as well), so \CFA treats them as overloadable identifiers.
+Furthermore, the constants ``©0©'' and ``©1©'' have special status for many of C's data types (and for many programmer-defined data types as well), so \CFA treats them as overloadable identifiers.
 Programmers can use these identifiers to declare functions and objects that implement operators and constants for their own types.
 …
 \begin{syntax}
 \oldlhs{identifier}
 \rhs \lstinline$0$
 \rhs \lstinline$1$
+\rhs ©0©
+\rhs ©1©
 \end{syntax}
 \index{constant identifiers}\index{identifiers!for constants} The tokens ``\lstinline$0$''\impl{0} and ``\lstinline$1$''\impl{1} are identifiers.
+\index{constant identifiers}\index{identifiers!for constants} The tokens ``©0©''\impl{0} and ``©1©''\impl{1} are identifiers.
 No other tokens defined by the rules for integer constants are considered to be identifiers.
 \begin{rationale}
 Why ``\lstinline$0$'' and ``\lstinline$1$''? Those integers have special status in C.
+Why ``©0©'' and ``©1©''? Those integers have special status in C.
 All scalar types can be incremented and decremented, which is defined in terms of adding or subtracting 1.
 The operations ``\lstinline$&&$'', ``\lstinline$||$'', and ``\lstinline$!$'' can be applied to any scalar arguments, and are defined in terms of comparison against 0.
+The operations ``©&&©'', ``©||©'', and ``©!©'' can be applied to any scalar arguments, and are defined in terms of comparison against 0.
 A \nonterm{constant-expression} that evaluates to 0 is effectively compatible with every pointer type.
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
 However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
 Defining special constants for a user-defined type is more efficient than defining a conversion to the type from \lstinline$_Bool$.
 Why \emph{just} ``\lstinline$0$'' and ``\lstinline$1$''? Why not other integers? No other integers have special status in C.
 A facility that let programmers declare specific constants---``\lstinline$const Rational 12$'', for instance---would not be much of an improvement.
+Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
+Why \emph{just} ``©0©'' and ``©1©''? Why not other integers? No other integers have special status in C.
+A facility that let programmers declare specific constants---``©const Rational 12©'', for instance---would not be much of an improvement.
 Some facility for defining the creation of values of programmer-defined types from arbitrary integer tokens would be needed.
 The complexity of such a feature doesn't seem worth the gain.
 …
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline$?[?]$ & subscripting \impl{?[?]}\\
 \lstinline$?()$ & function call \impl{?()}\\
 \lstinline$?++$ & postfix increment \impl{?++}\\
 \lstinline$?--$ & postfix decrement \impl{?--}\\
 \lstinline$++?$ & prefix increment \impl{++?}\\
 \lstinline$--?$ & prefix decrement \impl{--?}\\
 \lstinline$*?$ & dereference \impl{*?}\\
 \lstinline$+?$ & unary plus \impl{+?}\\
 \lstinline$-?$ & arithmetic negation \impl{-?}\\
 \lstinline$~?$ & bitwise negation \impl{~?}\\
 \lstinline$!?$ & logical complement \impl{"!?}\\
 \lstinline$?*?$ & multiplication \impl{?*?}\\
 \lstinline$?/?$ & division \impl{?/?}\\
+©?[?]© & subscripting \impl{?[?]}\\
+©?()© & function call \impl{?()}\\
+©?++© & postfix increment \impl{?++}\\
+©?--© & postfix decrement \impl{?--}\\
+©++?© & prefix increment \impl{++?}\\
+©--?© & prefix decrement \impl{--?}\\
+©*?© & dereference \impl{*?}\\
+©+?© & unary plus \impl{+?}\\
+©-?© & arithmetic negation \impl{-?}\\
+©~?© & bitwise negation \impl{~?}\\
+©!?© & logical complement \impl{"!?}\\
+©?*?© & multiplication \impl{?*?}\\
+©?/?© & division \impl{?/?}\\
 \end{tabular}\hfil
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline$?%?$ & remainder \impl{?%?}\\
 \lstinline$?+?$ & addition \impl{?+?}\\
 \lstinline$?-?$ & subtraction \impl{?-?}\\
 \lstinline$?<<?$ & left shift \impl{?<<?}\\
 \lstinline$?>>?$ & right shift \impl{?>>?}\\
 \lstinline$?<?$ & less than \impl{?<?}\\
 \lstinline$?<=?$ & less than or equal \impl{?<=?}\\
 \lstinline$?>=?$ & greater than or equal \impl{?>=?}\\
 \lstinline$?>?$ & greater than \impl{?>?}\\
 \lstinline$?==?$ & equality \impl{?==?}\\
 \lstinline$?!=?$ & inequality \impl{?"!=?}\\
 \lstinline$?&?$ & bitwise AND \impl{?&?}\\
+©?%?© & remainder \impl{?%?}\\
+©?+?© & addition \impl{?+?}\\
+©?-?© & subtraction \impl{?-?}\\
+©?<<?© & left shift \impl{?<<?}\\
+©?>>?© & right shift \impl{?>>?}\\
+©?<?© & less than \impl{?<?}\\
+©?<=?© & less than or equal \impl{?<=?}\\
+©?>=?© & greater than or equal \impl{?>=?}\\
+©?>?© & greater than \impl{?>?}\\
+©?==?© & equality \impl{?==?}\\
+©?!=?© & inequality \impl{?"!=?}\\
+©?&?© & bitwise AND \impl{?&?}\\
 \end{tabular}\hfil
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline$?^?$ & exclusive OR \impl{?^?}\\
 \lstinline$?|?$ & inclusive OR \impl{?"|?}\\
 \lstinline$?=?$ & simple assignment \impl{?=?}\\
 \lstinline$?*=?$ & multiplication assignment \impl{?*=?}\\
 \lstinline$?/=?$ & division assignment \impl{?/=?}\\
 \lstinline$?%=?$ & remainder assignment \impl{?%=?}\\
 \lstinline$?+=?$ & addition assignment \impl{?+=?}\\
 \lstinline$?-=?$ & subtraction assignment \impl{?-=?}\\
 \lstinline$?<<=?$ & left-shift assignment \impl{?<<=?}\\
 \lstinline$?>>=?$ & right-shift assignment \impl{?>>=?}\\
 \lstinline$?&=?$ & bitwise AND assignment \impl{?&=?}\\
 \lstinline$?^=?$ & exclusive OR assignment \impl{?^=?}\\
 \lstinline$?|=?$ & inclusive OR assignment \impl{?"|=?}\\
+©?^?© & exclusive OR \impl{?^?}\\
+©?|?© & inclusive OR \impl{?"|?}\\
+©?=?© & simple assignment \impl{?=?}\\
+©?*=?© & multiplication assignment \impl{?*=?}\\
+©?/=?© & division assignment \impl{?/=?}\\
+©?%=?© & remainder assignment \impl{?%=?}\\
+©?+=?© & addition assignment \impl{?+=?}\\
+©?-=?© & subtraction assignment \impl{?-=?}\\
+©?<<=?© & left-shift assignment \impl{?<<=?}\\
+©?>>=?© & right-shift assignment \impl{?>>=?}\\
+©?&=?© & bitwise AND assignment \impl{?&=?}\\
+©?^=?© & exclusive OR assignment \impl{?^=?}\\
+©?|=?© & inclusive OR assignment \impl{?"|=?}\\
 \end{tabular}
 \hfil
 …
 \begin{rationale}
 The use of ``\lstinline$?$'' in identifiers means that some C programs are not \CFA programs.  For instance, the sequence of characters ``\lstinline$(i < 0)?--i:i$'' is legal in a C program, but a
 \CFA compiler detects a syntax error because it treats ``\lstinline$?--$'' as an identifier, not as the two tokens ``\lstinline$?$'' and ``\lstinline$--$''.
+The use of ``©?©'' in identifiers means that some C programs are not \CFA programs.  For instance, the sequence of characters ``©(i < 0)?--i:i©'' is legal in a C program, but a
+\CFA compiler detects a syntax error because it treats ``©?--©'' as an identifier, not as the two tokens ``©?©'' and ``©--©''.
 \end{rationale}
 …
 \begin{itemize}
 \item
+The logical operators ``\lstinline$&&$'' and ``\lstinline$||$'', and the conditional operator
+``\lstinline$?:$''.
+The logical operators ``©&&©'' and ``©||©'', and the conditional operator ``©?:©''.
 These operators do not always evaluate their operands, and hence can not be properly defined by functions unless some mechanism like call-by-name is added to the language.
 Note that the definitions of ``\lstinline$&&$'' and ``\lstinline$||$'' say that they work by checking that their arguments are unequal to 0, so defining ``\lstinline$!=$'' and ``\lstinline$0$'' for user-defined types is enough to allow them to be used in logical expressions.
+Note that the definitions of ``©&&©'' and ``©||©'' say that they work by checking that their arguments are unequal to 0, so defining ``©!=©'' and ``©0©'' for user-defined types is enough to allow them to be used in logical expressions.
 \item
 …
 \item
 The ``address of'' operator.
 It would seem useful to define a unary ``\lstinline$&$'' operator that returns values of some programmer-defined pointer-like type.
+It would seem useful to define a unary ``©&©'' operator that returns values of some programmer-defined pointer-like type.
 The problem lies with the type of the operator.
+Consider the expression ``\lstinline$p = &x$'', where \lstinline$x$ is of type
+\lstinline$T$ and \lstinline$p$ has the programmer-defined type \lstinline$T_ptr$.
+The expression might be treated as a call to the unary function ``\lstinline$&?$''.
+Now what is the type of the function's parameter? It can not be \lstinline$T$, because then \lstinline$x$ would be passed by value, and there is no way to create a useful pointer-like result from a value.
+Hence the parameter must have type \lstinline$T *$.
+But then the expression must be rewritten as ``\lstinline$p = &?( &x )$''
+Consider the expression ``©p = &x©'', where ©x© is of type ©T© and ©p© has the programmer-defined type ©T_ptr©.
+The expression might be treated as a call to the unary function ``©&?©''.
+Now what is the type of the function's parameter? It can not be ©T©, because then ©x© would be passed by value, and there is no way to create a useful pointer-like result from a value.
+Hence the parameter must have type ©T *©.
+But then the expression must be rewritten as ``©p = &?( &x )©''
 ---which doesn't seem like progress!
 The rule for address-of expressions would have to be something like ``keep applying address-of functions until you get one that takes a pointer argument, then use the built-in operator and stop''.
 It seems simpler to define a conversion function from \lstinline$T *$ to \lstinline$T_ptr$.
 \item
 The \lstinline$sizeof$ operator.
+It seems simpler to define a conversion function from ©T *© to ©T_ptr©.
+\item
+The ©sizeof© operator.
 It is already defined for every object type, and intimately tied into the language's storage allocation model.
 Redefining it seems pointless.
 \item
 The ``member of'' operators ``\lstinline$.$'' and ``\lstinline$->$''.
+The ``member of'' operators ``©.©'' and ``©->©''.
 These are not really infix operators, since their right ``operand'' is not a value or object.
 …
 The ``fewest unsafe conversions'' rule ensures that the usual conversions are done, if possible.
 The ``lowest total expression cost'' rule chooses the proper common type.
 The odd-looking ``highest argument conversion cost'' rule ensures that, when unary expressions must be converted, conversions of function results are preferred to conversion of function arguments: \lstinline$(double)-i$ will be preferred to \lstinline$-(double)i$.
+The odd-looking ``highest argument conversion cost'' rule ensures that, when unary expressions must be converted, conversions of function results are preferred to conversion of function arguments: ©(double)-i© will be preferred to ©-(double)i©.
 The ``least polymorphic'' rule reduces the number of polymorphic function calls, since such functions are presumably more expensive than monomorphic functions and since the more specific function is presumably more appropriate.
+It also gives preference to monomorphic values (such as the
+\lstinline$int$ \lstinline$0$) over polymorphic values (such as the \Index{null pointer}
+\lstinline$0$\use{0}).
+It also gives preference to monomorphic values (such as the ©int© ©0©) over polymorphic values (such as the \Index{null pointer} ©0©\use{0}).
 However, interpretations that call polymorphic functions are preferred to interpretations that perform unsafe conversions, because those conversions potentially lose accuracy or violate strong typing.
 …
 \begin{rationale}
 Predefined functions and constants have internal linkage because that simplifies optimization in traditional compile-and-link environments.
 For instance, ``\lstinline$an_int + an_int$'' is equivalent to ``\lstinline$?+?(an_int, an_int)$''.
+For instance, ``©an_int + an_int©'' is equivalent to ``©?+?(an_int, an_int)©''.
 If integer addition has not been redefined in the current scope, a compiler can generate code to perform the addition directly.
 If predefined functions had external linkage, this optimization would be difficult.
 …
 \rhs \nonterm{constant}
 \rhs \nonterm{string-literal}
 \rhs \lstinline$($ \nonterm{expression} \lstinline$)$
+\rhs ©(© \nonterm{expression} ©)©
 \rhs \nonterm{generic-selection}
 \end{syntax}
 …
 \predefined
 \begin{lstlisting}
 const int 1;@\use{1}@
 const int 0;@\use{0}@
+const int 1;§\use{1}§
+const int 0;§\use{0}§
 forall( dtype DT ) DT * const 0;
 forall( ftype FT ) FT * const 0;
 …
 A \nonterm{constant} or \nonterm{string-literal} has one valid interpretation, which has the type and value defined by {\c11}.
 The predefined integer identifiers ``\lstinline$1$'' and ``\lstinline$0$'' have the integer values 1 and 0, respectively.
 The other two predefined ``\lstinline$0$'' identifiers are bound to polymorphic pointer values that, when specialized\index{specialization} with a data type or function type respectively, produce a null pointer of that type.
+The predefined integer identifiers ``©1©'' and ``©0©'' have the integer values 1 and 0, respectively.
+The other two predefined ``©0©'' identifiers are bound to polymorphic pointer values that, when specialized\index{specialization} with a data type or function type respectively, produce a null pointer of that type.
 A parenthesised expression has the same interpretations as the contained \nonterm{expression}.
 \examples
+The expression \lstinline$(void *)0$\use{0} specializes the (polymorphic) null pointer to a null pointer to \lstinline$void$. \lstinline$(const void *)0$ does the same, and also uses a safe conversion from \lstinline$void *$ to \lstinline$const void *$.
+In each case, the null pointer conversion is better\index{best valid interpretations} than the unsafe conversion of the integer
+\lstinline$0$ to a pointer.
+The expression ©(void *)0©\use{0} specializes the (polymorphic) null pointer to a null pointer to ©void©. ©(const void *)0© does the same, and also uses a safe conversion from ©void *© to ©const void *©.
+In each case, the null pointer conversion is better\index{best valid interpretations} than the unsafe conversion of the integer ©0© to a pointer.
 \begin{rationale}
 …
 \CFA does not have C's concept of ``null pointer constants'', which are not typed values but special strings of tokens.
+The C token ``\lstinline$0$'' is an expression of type \lstinline$int$ with the value ``zero'', and it \emph{also} is a null pointer constant.
+Similarly,
+``\lstinline$(void *)0$ is an expression of type \lstinline$(void *)$ whose value is a null pointer, and it also is a null pointer constant.
+However, in C, ``\lstinline$(void *)(void *)0$'' is
+The C token ``©0©'' is an expression of type ©int© with the value ``zero'', and it \emph{also} is a null pointer constant.
+Similarly, ``©(void *)0© is an expression of type ©(void *)© whose value is a null pointer, and it also is a null pointer constant.
+However, in C, ``©(void *)(void *)0©'' is
 \emph{not} a null pointer constant, even though it is null-valued, a pointer, and constant! The semantics of C expressions contain many special cases to deal with subexpressions that are null pointer constants.
 …
 \begin{lstlisting}
 forall( dtype DT ) DT * const 0;
 \end{lstlisting} means that \lstinline$0$ is a polymorphic object, and contains a value that can have \emph{any} pointer-to-object type or pointer-to-incomplete type.
+\end{lstlisting} means that ©0© is a polymorphic object, and contains a value that can have \emph{any} pointer-to-object type or pointer-to-incomplete type.
 The only such value is the null pointer.
 Therefore the type \emph{alone} is enough to identify a null pointer.
 …
 \constraints The best interpretation of the controlling expression shall be unambiguous\index{ambiguous interpretation}, and shall have type compatible with at most one of the types named in its generic association list.
 If a generic selection has no \lstinline$default$ generic association, the best interpretation of its controlling expression shall have type compatible with exactly one of the types named in its generic association list.
+If a generic selection has no ©default© generic association, the best interpretation of its controlling expression shall have type compatible with exactly one of the types named in its generic association list.
 \semantics
 …
 \lhs{postfix-expression}
 \rhs \nonterm{primary-expression}
 \rhs \nonterm{postfix-expression} \lstinline$[$ \nonterm{expression} \lstinline$]$
 \rhs \nonterm{postfix-expression} \lstinline$($
          \nonterm{argument-expression-list}\opt \lstinline$)$
 \rhs \nonterm{postfix-expression} \lstinline$.$ \nonterm{identifier}
 \rhs \nonterm{postfix-expression} \lstinline$->$ \nonterm{identifier}
 \rhs \nonterm{postfix-expression} \lstinline$++$
 \rhs \nonterm{postfix-expression} \lstinline$--$
 \rhs \lstinline$($ \nonterm{type-name} \lstinline$)$ \lstinline${$ \nonterm{initializer-list} \lstinline$}$
 \rhs \lstinline$($ \nonterm{type-name} \lstinline$)$ \lstinline${$ \nonterm{initializer-list} \lstinline$,$ \lstinline$}$
+\rhs \nonterm{postfix-expression} ©[© \nonterm{expression} ©]©
+\rhs \nonterm{postfix-expression} ©(©
+         \nonterm{argument-expression-list}\opt ©)©
+\rhs \nonterm{postfix-expression} ©.© \nonterm{identifier}
+\rhs \nonterm{postfix-expression} ©->© \nonterm{identifier}
+\rhs \nonterm{postfix-expression} ©++©
+\rhs \nonterm{postfix-expression} ©--©
+\rhs ©(© \nonterm{type-name} ©)© ©{© \nonterm{initializer-list} ©}©
+\rhs ©(© \nonterm{type-name} ©)© ©{© \nonterm{initializer-list} ©,© ©}©
 \lhs{argument-expression-list}
 \rhs \nonterm{assignment-expression}
 \rhs \nonterm{argument-expression-list} \lstinline$,$
+\rhs \nonterm{argument-expression-list} ©,©
          \nonterm{assignment-expression}
 \end{syntax}
 …
 \rewriterules
 \begin{lstlisting}
 a[b] @\rewrite@ ?[?]( b, a ) // if a has integer type@\use{?[?]}@
 a[b] @\rewrite@ ?[?]( a, b ) // otherwise
 a( @\emph{arguments}@ ) @\rewrite@ ?()( a, @\emph{arguments}@ )@\use{?()}@
 a++ @\rewrite@ ?++(&( a ))@\use{?++}@
 a-- @\rewrite@ ?--(&( a ))@\use{?--}@
+a[b] => ?[?]( b, a ) // if a has integer type§\use{?[?]}§
+a[b] => ?[?]( a, b ) // otherwise
+a( §\emph{arguments}§ ) => ?()( a, §\emph{arguments}§ )§\use{?()}§
+a++ => ?++(&( a ))§\use{?++}§
+a-- => ?--(&( a ))§\use{?--}§
 \end{lstlisting}
 …
 \predefined
 \begin{lstlisting}
 forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t );@\use{ptrdiff_t}@
+forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t );§\use{ptrdiff_t}§
 forall( otype T ) lvalue _Atomic T ?[?]( _Atomic T *, ptrdiff_t );
 forall( otype T ) lvalue const T ?[?]( const T *, ptrdiff_t );
 …
 The interpretations of subscript expressions are the interpretations of the corresponding function call expressions.
 \begin{rationale}
+C defines subscripting as pointer arithmetic in a way that makes \lstinline$a[i]$ and
+\lstinline$i[a]$ equivalent. \CFA provides the equivalence through a rewrite rule to reduce the number of overloadings of \lstinline$?[?]$.
+C defines subscripting as pointer arithmetic in a way that makes ©a[i]© and ©i[a]© equivalent. \CFA provides the equivalence through a rewrite rule to reduce the number of overloadings of ©?[?]©.
 Subscript expressions are rewritten as function calls that pass the first parameter by value.
 This is somewhat unfortunate, since array-like types tend to be large.
 The alternative is to use the rewrite rule ``\lstinline$a[b]$ \rewrite \lstinline$?[?](&(a), b)$''.
 However, C semantics forbid this approach: the \lstinline$a$ in ``\lstinline$a[b]$'' can be an arbitrary pointer value, which does not have an address.
+The alternative is to use the rewrite rule ``©a[b] => ?[?](&(a), b)©''.
+However, C semantics forbid this approach: the ©a© in ``©a[b]©'' can be an arbitrary pointer value, which does not have an address.
 The repetitive form of the predefined identifiers shows up a deficiency\index{deficiencies!pointers
 …
 \nonterm{postfix-expression} in a function call may have some interpretations that are function designators and some that are not.
 For those interpretations of the \nonterm{postfix-expression} that are not function designators, the expression is rewritten and becomes a call of a function named ``\lstinline$?()$''.
+For those interpretations of the \nonterm{postfix-expression} that are not function designators, the expression is rewritten and becomes a call of a function named ``©?()©''.
 The valid interpretations of the rewritten expression are determined in the manner described below.
 …
 \begin{itemize}
 \item if the argument corresponds to a parameter in the function designator's prototype, the argument interpretation must have the same type as the corresponding parameter, or be implicitly convertible to the parameter's type
+\item if the function designator's type does not include a prototype or if the argument corresponds to
+``\lstinline$...$'' in a prototype, a \Index{default argument promotion} is applied to it.
+\item if the function designator's type does not include a prototype or if the argument corresponds to ``©...©'' in a prototype, a \Index{default argument promotion} is applied to it.
 \end{itemize}
 The type of the valid interpretation is the return type of the function designator.
+For those combinations where the interpretation of the \nonterm{postfix-expression} is a
+\Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
+For those combinations where the interpretation of the \nonterm{postfix-expression} is a \Index{polymorphic function} designator and the function designator accepts the number of arguments given, there shall be at least one set of \define{implicit argument}s for the implicit parameters such that
 \begin{itemize}
 \item
 If the declaration of the implicit parameter uses \Index{type-class} \lstinline$type$\use{type}, the implicit argument must be an object type;
 if it uses \lstinline$dtype$, the implicit argument must be an object type or an incomplete type;
 and if it uses \lstinline$ftype$, the implicit argument must be a function type.
+If the declaration of the implicit parameter uses \Index{type-class} ©type©\use{type}, the implicit argument must be an object type;
+if it uses ©dtype©, the implicit argument must be an object type or an incomplete type;
+and if it uses ©ftype©, the implicit argument must be a function type.
 \item if an explicit parameter's type uses any implicit parameters, then the corresponding explicit argument must have a type that is (or can be safely converted\index{safe conversion} to) the type produced by substituting the implicit arguments for the implicit parameters in the explicit parameter type.
 …
 \begin{rationale}
 One desirable property of a polymorphic programming language is \define{generalizability}: the ability to replace an abstraction with a more general but equivalent abstraction without requiring changes in any of the uses of the original\cite{Cormack90}.
+For instance, it should be possible to replace a function ``\lstinline$int f( int );$'' with ``\lstinline$forall( otype T ) T f( T );$'' without affecting any calls of \lstinline$f$.
+\CFA\index{deficiencies!generalizability} does not fully possess this property, because
+\Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
+For instance, it should be possible to replace a function ``©int f( int );©'' with ``©forall( otype T ) T f( T );©'' without affecting any calls of ©f©.
+\CFA\index{deficiencies!generalizability} does not fully possess this property, because \Index{unsafe conversion} are not done when arguments are passed to polymorphic parameters.
 Consider
 \begin{lstlisting}
 …
 f = g( d, f );          // (3) (unsafe conversion to float)
 \end{lstlisting}
+If \lstinline$g$ was replaced by ``\lstinline$forall( otype T ) T g( T, T );$'', the first and second calls would be unaffected, but the third would change: \lstinline$f$ would be converted to
+\lstinline$double$, and the result would be a \lstinline$double$.
+Another example is the function ``\lstinline$void h( int *);$''.
+This function can be passed a
+\lstinline$void *$ argument, but the generalization ``\lstinline$forall( otype T ) void h( T *);$'' can not.
+In this case, \lstinline$void$ is not a valid value for \lstinline$T$ because it is not an object type.
+If unsafe conversions were allowed, \lstinline$T$ could be inferred to be \emph{any} object type, which is undesirable.
+If ©g© was replaced by ``©forall( otype T ) T g( T, T );©'', the first and second calls would be unaffected, but the third would change: ©f© would be converted to ©double©, and the result would be a ©double©.
+Another example is the function ``©void h( int *);©''.
+This function can be passed a ©void *© argument, but the generalization ``©forall( otype T ) void h( T *);©'' can not.
+In this case, ©void© is not a valid value for ©T© because it is not an object type.
+If unsafe conversions were allowed, ©T© could be inferred to be \emph{any} object type, which is undesirable.
 \end{rationale}
 \examples
 A function called ``\lstinline$?()$'' might be part of a numerical differentiation package.
+A function called ``©?()©'' might be part of a numerical differentiation package.
 \begin{lstlisting}
 extern otype Derivative;
 …
 d = sin_dx( 12.9 );
 \end{lstlisting}
 Here, the only interpretation of \lstinline$sin_dx$ is as an object of type \lstinline$Derivative$.
 For that interpretation, the function call is treated as ``\lstinline$?()( sin_dx, 12.9 )$''.
+Here, the only interpretation of ©sin_dx© is as an object of type ©Derivative©.
+For that interpretation, the function call is treated as ``©?()( sin_dx, 12.9 )©''.
 \begin{lstlisting}
 int f( long );          // (1)
 …
 int i = f( 5 );         // calls (1)
 \end{lstlisting}
 Function (1) provides a valid interpretation of ``\lstinline$f( 5 )$'', using an implicit \lstinline$int$ to \lstinline$long$ conversion.
 The other functions do not, since the second requires two arguments, and since there is no implicit conversion from \lstinline$int$ to \lstinline$int *$ that could be used with the third function.
+Function (1) provides a valid interpretation of ``©f( 5 )©'', using an implicit ©int© to ©long© conversion.
+The other functions do not, since the second requires two arguments, and since there is no implicit conversion from ©int© to ©int *© that could be used with the third function.
 \begin{lstlisting}
 …
 double d = h( 1.5 );
 \end{lstlisting}
+``\lstinline$1.5$'' is a \lstinline$double$ constant, so \lstinline$T$ is inferred to be
+\lstinline$double$, and the result of the function call is a \lstinline$double$.
+``©1.5©'' is a ©double© constant, so ©T© is inferred to be ©double©, and the result of the function call is a ©double©.
 \begin{lstlisting}
 forall( otype T, otype U ) void g( T, U );      // (4)
 forall( otype T ) void g( T, T );                       // (5)
 forall( otype T ) void g( T, long );                    // (6)
+forall( otype T ) void g( T, long );            // (6)
 void g( long, long );                                           // (7)
 double d;
 int i;
 int *p;
 g( d, d );                      // calls (5)
 g( d, i );                      // calls (6)
 g( i, i );                      // calls (7)
 g( i, p );                      // calls (4)
 \end{lstlisting}
 The first call has valid interpretations for all four versions of \lstinline$g$. (6) and (7) are discarded because they involve unsafe \lstinline$double$-to-\lstinline$long$ conversions. (5) is chosen because it is less polymorphic than (4).
+g( d, d );                                                                      // calls (5)
+g( d, i );                                                                      // calls (6)
+g( i, i );                                                                      // calls (7)
+g( i, p );                                                                      // calls (4)
+\end{lstlisting}
+The first call has valid interpretations for all four versions of ©g©. (6) and (7) are discarded because they involve unsafe ©double©-to-©long© conversions. (5) is chosen because it is less polymorphic than (4).
 For the second call, (7) is again discarded.
 Of the remaining interpretations for (4), (5), and (6) (with \lstinline$i$ converted to \lstinline$long$), (6) is chosen because it is the least polymorphic.
+Of the remaining interpretations for (4), (5), and (6) (with ©i© converted to ©long©), (6) is chosen because it is the least polymorphic.
 The third call has valid interpretations for all of the functions;
 …
 forall( otype T ) T min( T, T );
 double max( double, double );
 trait min_max( T ) {@\impl{min_max}@
+trait min_max( T ) {§\impl{min_max}§
         T min( T, T );
         T max( T, T );
 …
 shuffle( 9, 10 );
 \end{lstlisting}
+The only possibility for \lstinline$U$ is \lstinline$double$, because that is the type used in the only visible \lstinline$max$ function. 9 and 10 must be converted to \lstinline$double$, and
+\lstinline$min$ must be specialized with \lstinline$T$ bound to \lstinline$double$.
+\begin{lstlisting}
+extern void q( int );           // (8)
+extern void q( void * );        // (9)
+The only possibility for ©U© is ©double©, because that is the type used in the only visible ©max© function. 9 and 10 must be converted to ©double©, and ©min© must be specialized with ©T© bound to ©double©.
+\begin{lstlisting}
+extern void q( int );                                           // (8)
+extern void q( void * );                                        // (9)
 extern void r();
 q( 0 );
 r( 0 );
 \end{lstlisting}
 The \lstinline$int 0$ could be passed to (8), or the \lstinline$(void *)$ \Index{specialization} of the null pointer\index{null pointer} \lstinline$0$\use{0} could be passed to (9).
 The former is chosen because the \lstinline$int$ \lstinline$0$ is \Index{less polymorphic}.
 For the same reason, \lstinline$int$ \lstinline$0$ is passed to \lstinline$r()$, even though it has \emph{no} declared parameter types.
+The ©int 0© could be passed to (8), or the ©(void *)© \Index{specialization} of the null pointer\index{null pointer} ©0©\use{0} could be passed to (9).
+The former is chosen because the ©int© ©0© is \Index{less polymorphic}.
+For the same reason, ©int© ©0© is passed to ©r()©, even though it has \emph{no} declared parameter types.
 \subsubsection{Structure and union members}
+\semantics In the member selection expression ``\lstinline$s$.\lstinline$m$'', there shall be at least one interpretation of \lstinline$s$ whose type is a structure type or union type containing a member named \lstinline$m$.
+If two or more interpretations of \lstinline$s$ have members named
+\lstinline$m$ with mutually compatible types, then the expression has an \Index{ambiguous interpretation} whose type is the composite type of the types of the members.
+If an interpretation of \lstinline$s$ has a member \lstinline$m$ whose type is not compatible with any other
+\lstinline$s$'s \lstinline$m$, then the expression has an interpretation with the member's type.
+\semantics In the member selection expression ``©s©.©m©'', there shall be at least one interpretation of ©s© whose type is a structure type or union type containing a member named ©m©.
+If two or more interpretations of ©s© have members named ©m© with mutually compatible types, then the expression has an \Index{ambiguous interpretation} whose type is the composite type of the types of the members.
+If an interpretation of ©s© has a member ©m© whose type is not compatible with any other ©s©'s ©m©, then the expression has an interpretation with the member's type.
 The expression has no other interpretations.
+The expression ``\lstinline$p->m$'' has the same interpretations as the expression
+``\lstinline$(*p).m$''.
+The expression ``©p->m©'' has the same interpretations as the expression ``©(*p).m©''.
 …
         * ?--( _Atomic const restrict volatile T * _Atomic restrict volatile * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ there exist
+For every extended integer type ©X© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
   ?--( volatile X * ), ?--( _Atomic volatile X * );
 \end{lstlisting}
 For every complete enumerated type \lstinline$E$ there exist
+For every complete enumerated type ©E© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \begin{rationale}
 Note that ``\lstinline$++$'' and ``\lstinline$--$'' are rewritten as function calls that are given a pointer to that operand. (This is true of all operators that modify an operand.) As Hamish Macdonald has pointed out, this forces the modified operand of such expressions to be an lvalue.
+Note that ``©++©'' and ``©--©'' are rewritten as function calls that are given a pointer to that operand. (This is true of all operators that modify an operand.) As Hamish Macdonald has pointed out, this forces the modified operand of such expressions to be an lvalue.
 This partially enforces the C semantic rule that such operands must be \emph{modifiable} lvalues.
 \end{rationale}
 …
 \begin{rationale}
 In C, a semantic rule requires that pointer operands of increment and decrement be pointers to object types.
 Hence, \lstinline$void *$ objects cannot be incremented.
 In \CFA, the restriction follows from the use of a \lstinline$type$ parameter in the predefined function definitions, as opposed to \lstinline$dtype$, since only object types can be inferred arguments corresponding to the type parameter \lstinline$T$.
+Hence, ©void *© objects cannot be incremented.
+In \CFA, the restriction follows from the use of a ©type© parameter in the predefined function definitions, as opposed to ©dtype©, since only object types can be inferred arguments corresponding to the type parameter ©T©.
 \end{rationale}
 \semantics
 First, each interpretation of the operand of an increment or decrement expression is considered separately.
+For each interpretation that is a bit-field or is declared with the
+\lstinline$register$\index{register@{\lstinline$register$}} \index{Itorage-class specifier}, the expression has one valid interpretation, with the type of the operand, and the expression is ambiguous if the operand is.
+For each interpretation that is a bit-field or is declared with the \Indexc{register}\index{storage-class specifier}, the expression has one valid interpretation, with the type of the operand, and the expression is ambiguous if the operand is.
 For the remaining interpretations, the expression is rewritten, and the interpretations of the expression are the interpretations of the corresponding function call.
 …
 \end{lstlisting}
 \begin{sloppypar}
+Since \lstinline$&(vs)$ has type \lstinline$volatile short int *$, the best valid interpretation of
+\lstinline$vs++$ calls the \lstinline$?++$ function with the \lstinline$volatile short *$ parameter.
+\lstinline$s++$ does the same, applying the safe conversion from \lstinline$short int *$ to
+\lstinline$volatile short int *$.
+Note that there is no conversion that adds an \lstinline$_Atomic$ qualifier, so the \lstinline$_Atomic volatile short int$ overloading does not provide a valid interpretation.
+Since ©&(vs)© has type ©volatile short int *©, the best valid interpretation of ©vs++© calls the ©?++© function with the ©volatile short *© parameter.
+©s++© does the same, applying the safe conversion from ©short int *© to ©volatile short int *©.
+Note that there is no conversion that adds an ©_Atomic© qualifier, so the ©_Atomic volatile short int© overloading does not provide a valid interpretation.
 \end{sloppypar}
 There is no safe conversion from \lstinline$const short int *$ to \lstinline$volatile short int *$, and no \lstinline$?++$ function that accepts a \lstinline$const *$ parameter, so \lstinline$cs++$ has no valid interpretations.
 The best valid interpretation of \lstinline$as++$ calls the \lstinline$short ?++$ function with the \lstinline$_Atomic volatile short int *$ parameter, applying a safe conversion to add the \lstinline$volatile$ qualifier.
+There is no safe conversion from ©const short int *© to ©volatile short int *©, and no ©?++© function that accepts a ©const *© parameter, so ©cs++© has no valid interpretations.
+The best valid interpretation of ©as++© calls the ©short ?++© function with the ©_Atomic volatile short int *© parameter, applying a safe conversion to add the ©volatile© qualifier.
 \begin{lstlisting}
 char * const restrict volatile * restrict volatile pqpc;
 …
 ppc++;
 \end{lstlisting}
 Since \lstinline$&(pqpc)$ has type \lstinline$char * const restrict volatile * restrict volatile *$, the best valid interpretation of \lstinline$pqpc++$ calls the polymorphic \lstinline$?++$ function with the \lstinline$const restrict volatile T * restrict volatile *$ parameter, inferring \lstinline$T$ to be \lstinline$char *$.
 \lstinline$ppc++$ calls the same function, again inferring \lstinline$T$ to be \lstinline$char *$, and using the safe conversions from \lstinline$T$ to \lstinline$T const$ \lstinline$restrict volatile$.
+Since ©&(pqpc)© has type ©char * const restrict volatile * restrict volatile *©, the best valid interpretation of ©pqpc++© calls the polymorphic ©?++© function with the ©const restrict volatile T * restrict volatile *© parameter, inferring ©T© to be ©char *©.
+©ppc++© calls the same function, again inferring ©T© to be ©char *©, and using the safe conversions from ©T© to ©T const© ©restrict volatile©.
 \begin{rationale}
 …
 \begin{enumerate}
 \item
 ``\lstinline$char * p; p++;$''.
 The argument to \lstinline$?++$ has type \lstinline$char * *$, and the result has type \lstinline$char *$.
 The expression would be valid if \lstinline$?++$ were declared by
+``©char * p; p++;©''.
+The argument to ©?++© has type ©char * *©, and the result has type ©char *©.
+The expression would be valid if ©?++© were declared by
 \begin{lstlisting}
 forall( otype T ) T * ?++( T * * );
 \end{lstlisting} with \lstinline$T$ inferred to be \lstinline$char$.
 \item
 ``\lstinline$char *restrict volatile qp; qp++$''.
 The result again has type \lstinline$char *$, but the argument now has type \lstinline$char *restrict volatile *$, so it cannot be passed to the hypothetical function declared in point 1.
+\end{lstlisting} with ©T© inferred to be ©char©.
+\item
+``©char *restrict volatile qp; qp++©''.
+The result again has type ©char *©, but the argument now has type ©char *restrict volatile *©, so it cannot be passed to the hypothetical function declared in point 1.
 Hence the actual predefined function is
 \begin{lstlisting}
 forall( otype T ) T * ?++( T * restrict volatile * );
+\end{lstlisting} which also accepts a \lstinline$char * *$ argument, because of the safe conversions that add
+\lstinline$volatile$ and \lstinline$restrict$ qualifiers. (The parameter is not const-qualified, so constant pointers cannot be incremented.)
+\item
+``\lstinline$char *_Atomic ap; ap++$''.
+The result again has type \lstinline$char *$, but no safe conversion adds an \lstinline$_Atomic$ qualifier, so the function in point 2 is not applicable.
+A separate overloading of \lstinline$?++$ is required.
+\item
+``\lstinline$char const volatile * pq; pq++$''.
+Here the result has type
+\lstinline$char const volatile *$, so a new overloading is needed:
+\end{lstlisting} which also accepts a ©char * *© argument, because of the safe conversions that add ©volatile© and ©restrict© qualifiers. (The parameter is not const-qualified, so constant pointers cannot be incremented.)
+\item
+``©char *_Atomic ap; ap++©''.
+The result again has type ©char *©, but no safe conversion adds an ©_Atomic© qualifier, so the function in point 2 is not applicable.
+A separate overloading of ©?++© is required.
+\item
+``©char const volatile * pq; pq++©''.
+Here the result has type ©char const volatile *©, so a new overloading is needed:
 \begin{lstlisting}
 forall( otype T ) T const volatile * ?++( T const volatile *restrict volatile * );
 …
 \item
 ``\lstinline$float *restrict * prp; prp++$''.
 The \lstinline$restrict$ qualifier is handled just like \lstinline$const$ and \lstinline$volatile$ in the previous case:
+``©float *restrict * prp; prp++©''.
+The ©restrict© qualifier is handled just like ©const© and ©volatile© in the previous case:
 \begin{lstlisting}
 forall( otype T ) T restrict * ?++( T restrict *restrict volatile * );
 \end{lstlisting} with \lstinline$T$ inferred to be \lstinline$float *$.
 This looks odd, because {\c11} contains a constraint that requires restrict-qualified types to be pointer-to-object types, and \lstinline$T$ is not syntactically a pointer type. \CFA loosens the constraint.
+\end{lstlisting} with ©T© inferred to be ©float *©.
+This looks odd, because {\c11} contains a constraint that requires restrict-qualified types to be pointer-to-object types, and ©T© is not syntactically a pointer type. \CFA loosens the constraint.
 \end{enumerate}
 \end{rationale}
 …
 \lhs{unary-expression}
 \rhs \nonterm{postfix-expression}
 \rhs \lstinline$++$ \nonterm{unary-expression}
 \rhs \lstinline$--$ \nonterm{unary-expression}
+\rhs ©++© \nonterm{unary-expression}
+\rhs ©--© \nonterm{unary-expression}
 \rhs \nonterm{unary-operator} \nonterm{cast-expression}
 \rhs \lstinline$sizeof$ \nonterm{unary-expression}
 \rhs \lstinline$sizeof$ \lstinline$($ \nonterm{type-name} \lstinline$)$
 \lhs{unary-operator} one of \rhs \lstinline$&$ \lstinline$*$ \lstinline$+$ \lstinline$-$ \lstinline$~$ \lstinline$!$
+\rhs ©sizeof© \nonterm{unary-expression}
+\rhs ©sizeof© ©(© \nonterm{type-name} ©)©
+\lhs{unary-operator} one of \rhs ©&© ©*© ©+© ©-© ©~© ©!©
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 *a      @\rewrite@ *?( a ) @\use{*?}@
 +a      @\rewrite@ +?( a ) @\use{+?}@
 -a      @\rewrite@ -?( a ) @\use{-?}@
 ~a      @\rewrite@ ~?( a ) @\use{~?}@
 !a      @\rewrite@ !?( a ) @\use{"!?}@
 ++a     @\rewrite@ ++?(&( a )) @\use{++?}@
 --a     @\rewrite@ --?(&( a )) @\use{--?}@
+*a      => *?( a )§\use{*?}§
++a      => +?( a )§\use{+?}§
+-a      => -?( a )§\use{-?}§
+~a      => ~?( a )§\use{~?}§
+!a      => !?( a )§\use{"!?}§
+++a     => ++?(&( a ))§\use{++?}§
+--a     => --?(&( a ))§\use{--?}§
 \end{lstlisting}
 …
         * --?( _Atomic const restrict volatile T * _Atomic restrict volatile * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ there exist
+For every extended integer type ©X© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
         --?( _Atomic volatile X * );
 \end{lstlisting}
 For every complete enumerated type \lstinline$E$ there exist
+For every complete enumerated type ©E© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \constraints
+The operand of the unary ``\lstinline$&$'' operator shall have exactly one
+\Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
+The operand of the unary ``©&©'' operator shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous.
 \semantics
+The ``\lstinline$&$'' expression has one interpretation which is of type \lstinline$T *$, where
+\lstinline$T$ is the type of the operand.
+The ``©&©'' expression has one interpretation which is of type ©T *©, where ©T© is the type of the operand.
 The interpretations of an indirection expression are the interpretations of the corresponding function call.
 …
 forall( ftype FT ) int !?( FT * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \begin{lstlisting}
 long int li;
 void eat_double( double );@\use{eat_double}@
 eat_double(-li ); // @\rewrite@ eat_double( -?( li ) );
 \end{lstlisting}
 The valid interpretations of ``\lstinline$-li$'' (assuming no extended integer types exist) are
+void eat_double( double );§\use{eat_double}§
+eat_double(-li ); // => eat_double( -?( li ) );
+\end{lstlisting}
+The valid interpretations of ``©-li©'' (assuming no extended integer types exist) are
 \begin{center}
 \begin{tabular}{llc} interpretation & result type & expression conversion cost \\
 \hline
 \lstinline$-?( (int)li )$                                       & \lstinline$int$                                       & (unsafe) \\
 \lstinline$-?( (unsigned)li)$                           & \lstinline$unsigned int$                      & (unsafe) \\
 \lstinline$-?( (long)li)$                                       & \lstinline$long$                                      & 0 \\
 \lstinline$-?( (long unsigned int)li)$          & \lstinline$long unsigned int$         & 1 \\
 \lstinline$-?( (long long int)li)$                      & \lstinline$long long int$                     & 2 \\
 \lstinline$-?( (long long unsigned int)li)$     & \lstinline$long long unsigned int$& 3 \\
 \lstinline$-?( (float)li)$                                      & \lstinline$float$                                     & 4 \\
 \lstinline$-?( (double)li)$                                     & \lstinline$double$                            & 5 \\
 \lstinline$-?( (long double)li)$                        & \lstinline$long double$                       & 6 \\
 \lstinline$-?( (_Complex float)li)$                     & \lstinline$float$                                     & (unsafe) \\
 \lstinline$-?( (_Complex double)li)$            & \lstinline$double$                            & (unsafe) \\
 \lstinline$-?( (_Complex long double)li)$       & \lstinline$long double$                       & (unsafe) \\
+©-?( (int)li )©                                         & ©int©                                         & (unsafe) \\
+©-?( (unsigned)li)©                                     & ©unsigned int©                        & (unsafe) \\
+©-?( (long)li)©                                         & ©long©                                        & 0 \\
+©-?( (long unsigned int)li)©            & ©long unsigned int©           & 1 \\
+©-?( (long long int)li)©                        & ©long long int©                       & 2 \\
+©-?( (long long unsigned int)li)©       & ©long long unsigned int©      & 3 \\
+©-?( (float)li)©                                        & ©float©                                       & 4 \\
+©-?( (double)li)©                                       & ©double©                                      & 5 \\
+©-?( (long double)li)©                          & ©long double©                         & 6 \\
+©-?( (_Complex float)li)©                       & ©float©                                       & (unsafe) \\
+©-?( (_Complex double)li)©                      & ©double©                                      & (unsafe) \\
+©-?( (_Complex long double)li)©         & ©long double©                         & (unsafe) \\
 \end{tabular}
 \end{center}
 The valid interpretations of the \lstinline$eat_double$ call, with the cost of the argument conversion and the cost of the entire expression, are
+The valid interpretations of the ©eat_double© call, with the cost of the argument conversion and the cost of the entire expression, are
 \begin{center}
 \begin{tabular}{lcc} interpretation & argument cost & expression cost \\
 \hline
 \lstinline$eat_double( (double)-?( (int)li) )$                                  & 7                     & (unsafe) \\
 \lstinline$eat_double( (double)-?( (unsigned)li) )$                             & 6                     & (unsafe) \\
 \lstinline$eat_double( (double)-?(li) )$                                                & 5                     & \(0+5=5\) \\
 \lstinline$eat_double( (double)-?( (long unsigned int)li) )$    & 4                     & \(1+4=5\) \\
 \lstinline$eat_double( (double)-?( (long long int)li) )$                & 3                     & \(2+3=5\) \\
 \lstinline$eat_double( (double)-?( (long long unsigned int)li) )$& 2            & \(3+2=5\) \\
 \lstinline$eat_double( (double)-?( (float)li) )$                                & 1                     & \(4+1=5\) \\
 \lstinline$eat_double( (double)-?( (double)li) )$                               & 0                     & \(5+0=5\) \\
 \lstinline$eat_double( (double)-?( (long double)li) )$                  & (unsafe)      & (unsafe) \\
 \lstinline$eat_double( (double)-?( (_Complex float)li) )$               & (unsafe)      & (unsafe) \\
 \lstinline$eat_double( (double)-?( (_Complex double)li) )$              & (unsafe)      & (unsafe) \\
 \lstinline$eat_double( (double)-?( (_Complex long double)li) )$ & (unsafe)      & (unsafe) \\
+©eat_double( (double)-?( (int)li) )©                                    & 7                     & (unsafe) \\
+©eat_double( (double)-?( (unsigned)li) )©                               & 6                     & (unsafe) \\
+©eat_double( (double)-?(li) )©                                                  & 5                     & \(0+5=5\) \\
+©eat_double( (double)-?( (long unsigned int)li) )©              & 4                     & \(1+4=5\) \\
+©eat_double( (double)-?( (long long int)li) )©                  & 3                     & \(2+3=5\) \\
+©eat_double( (double)-?( (long long unsigned int)li) )© & 2                     & \(3+2=5\) \\
+©eat_double( (double)-?( (float)li) )©                                  & 1                     & \(4+1=5\) \\
+©eat_double( (double)-?( (double)li) )©                                 & 0                     & \(5+0=5\) \\
+©eat_double( (double)-?( (long double)li) )©                    & (unsafe)      & (unsafe) \\
+©eat_double( (double)-?( (_Complex float)li) )©                 & (unsafe)      & (unsafe) \\
+©eat_double( (double)-?( (_Complex double)li) )©                & (unsafe)      & (unsafe) \\
+©eat_double( (double)-?( (_Complex long double)li) )©   & (unsafe)      & (unsafe) \\
 \end{tabular}
 \end{center}
 Each has result type \lstinline$void$, so the best must be selected.
+Each has result type ©void©, so the best must be selected.
 The interpretations involving unsafe conversions are discarded.
+The remainder have equal expression conversion costs, so the
+``highest argument conversion cost'' rule is invoked, and the chosen interpretation is
+\lstinline$eat_double( (double)-?(li) )$.
+\subsubsection{The \lstinline$sizeof$ and \lstinline$_Alignof$ operators}
+The remainder have equal expression conversion costs, so the ``highest argument conversion cost'' rule is invoked, and the chosen interpretation is ©eat_double( (double)-?(li) )©.
+\subsubsection[The sizeof and \_Alignof operators]{The \lstinline@sizeof@ and \lstinline@_Alignof@ operators}
 \constraints
+The operand of \lstinline$sizeof$ or \lstinline$_Alignof$ shall not be \lstinline$type$,
+\lstinline$dtype$, or \lstinline$ftype$.
+When the \lstinline$sizeof$\use{sizeof} operator is applied to an expression, the expression shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous. \semantics A \lstinline$sizeof$ or \lstinline$_Alignof$ expression has one interpretation, of type \lstinline$size_t$.
+When \lstinline$sizeof$ is applied to an identifier declared by a \nonterm{type-declaration} or a
+The operand of ©sizeof© or ©_Alignof© shall not be ©type©, ©dtype©, or ©ftype©.
+When the ©sizeof©\use{sizeof} operator is applied to an expression, the expression shall have exactly one \Index{interpretation}\index{ambiguous interpretation}, which shall be unambiguous. \semantics A ©sizeof© or ©_Alignof© expression has one interpretation, of type ©size_t©.
+When ©sizeof© is applied to an identifier declared by a \nonterm{type-declaration} or a
 \nonterm{type-parameter}, it yields the size in bytes of the type that implements the operand.
 When the operand is an opaque type or an inferred type parameter\index{inferred parameter}, the expression is not a constant expression.
 When \lstinline$_Alignof$ is applied to an identifier declared by a \nonterm{type-declaration} or a
+When ©_Alignof© is applied to an identifier declared by a \nonterm{type-declaration} or a
 \nonterm{type-parameter}, it yields the alignment requirement of the type that implements the operand.
 When the operand is an opaque type or an inferred type parameter\index{inferred parameter}, the expression is not a constant expression.
 …
 otype Pair = struct { int first, second; };
 size_t p_size = sizeof(Pair);           // constant expression
 extern otype Rational;@\use{Rational}@
+extern otype Rational;§\use{Rational}§
 size_t c_size = sizeof(Rational);       // non-constant expression
 forall(type T) T f(T p1, T p2) {
 …
+}
 \end{lstlisting}
+``\lstinline$sizeof Rational$'', although not statically known, is fixed.
+Within \lstinline$f()$,
+``\lstinline$sizeof(T)$'' is fixed for each call of \lstinline$f()$, but may vary from call to call.
+``©sizeof Rational©'', although not statically known, is fixed.
+Within ©f()©, ``©sizeof(T)©'' is fixed for each call of ©f()©, but may vary from call to call.
 \end{rationale}
 …
 \lhs{cast-expression}
 \rhs \nonterm{unary-expression}
 \rhs \lstinline$($ \nonterm{type-name} \lstinline$)$ \nonterm{cast-expression}
+\rhs ©(© \nonterm{type-name} ©)© \nonterm{cast-expression}
 \end{syntax}
 \constraints
+The \nonterm{type-name} in a \nonterm{cast-expression} shall not be \lstinline$type$,
+\lstinline$dtype$, or \lstinline$ftype$.
+The \nonterm{type-name} in a \nonterm{cast-expression} shall not be ©type©, ©dtype©, or ©ftype©.
 \semantics
 In a \Index{cast expression} ``\lstinline$($\nonterm{type-name}\lstinline$)e$'', if
 \nonterm{type-name} is the type of an interpretation of \lstinline$e$, then that interpretation is the only interpretation of the cast expression;
 otherwise, \lstinline$e$ shall have some interpretation that can be converted to \nonterm{type-name}, and the interpretation of the cast expression is the cast of the interpretation that can be converted at the lowest cost.
+In a \Index{cast expression} ``©(©\nonterm{type-name}©)e©'', if
+\nonterm{type-name} is the type of an interpretation of ©e©, then that interpretation is the only interpretation of the cast expression;
+otherwise, ©e© shall have some interpretation that can be converted to \nonterm{type-name}, and the interpretation of the cast expression is the cast of the interpretation that can be converted at the lowest cost.
 The cast expression's interpretation is ambiguous\index{ambiguous interpretation} if more than one interpretation can be converted at the lowest cost or if the selected interpretation is ambiguous.
 …
 \lhs{multiplicative-expression}
 \rhs \nonterm{cast-expression}
 \rhs \nonterm{multiplicative-expression} \lstinline$*$ \nonterm{cast-expression}
 \rhs \nonterm{multiplicative-expression} \lstinline$/$ \nonterm{cast-expression}
 \rhs \nonterm{multiplicative-expression} \lstinline$%$ \nonterm{cast-expression}
+\rhs \nonterm{multiplicative-expression} ©*© \nonterm{cast-expression}
+\rhs \nonterm{multiplicative-expression} ©/© \nonterm{cast-expression}
+\rhs \nonterm{multiplicative-expression} ©%© \nonterm{cast-expression}
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 a * b @\rewrite@ ?*?( a, b )@\use{?*?}@
 a / b @\rewrite@ ?/?( a, b )@\use{?/?}@
 a % b @\rewrite@ ?%?( a, b )@\use{?%?}@
+a * b => ?*?( a, b )§\use{?*?}§
+a / b => ?/?( a, b )§\use{?/?}§
+a % b => ?%?( a, b )§\use{?%?}§
 \end{lstlisting}
 …
         ?*?( _Complex long double, _Complex long double ), ?/?( _Complex long double, _Complex long double );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \begin{rationale}
+{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the
+\Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
+{\c11} does not include conversions from the \Index{real type}s to \Index{complex type}s in the \Index{usual arithmetic conversion}s.  Instead it specifies conversion of the result of binary operations on arguments from mixed type domains. \CFA's predefined operators match that pattern.
 \end{rationale}
 …
 int i;
 long li;
 void eat_double( double );@\use{eat_double}@
+void eat_double( double );§\use{eat_double}§
 eat_double( li % i );
 \end{lstlisting}
 ``\lstinline$li % i$'' is rewritten as ``\lstinline$?%?(li, i )$''.
 The valid interpretations of \lstinline$?%?(li, i )$, the cost\index{conversion cost} of converting their arguments, and the cost of converting the result to \lstinline$double$ (assuming no extended integer types are present ) are
+``©li % i©'' is rewritten as ``©?%?(li, i )©''.
+The valid interpretations of ©?%?(li, i )©, the cost\index{conversion cost} of converting their arguments, and the cost of converting the result to ©double© (assuming no extended integer types are present ) are
 \begin{center}
 \begin{tabular}{lcc} interpretation & argument cost & result cost \\
 \hline
 \lstinline$ ?%?( (int)li, i )$                                                                          & (unsafe)      & 6     \\
 \lstinline$ ?%?( (unsigned)li,(unsigned)i )$                                            & (unsafe)      & 5     \\
 \lstinline$ ?%?( li, (long)i )$                                                                         & 1                     & 4     \\
 \lstinline$ ?%?( (long unsigned)li,(long unsigned)i )$                          & 3                     & 3     \\
 \lstinline$ ?%?( (long long)li,(long long)i )$                                          & 5                     & 2     \\
 \lstinline$ ?%?( (long long unsigned)li, (long long unsigned)i )$       & 7                     & 1     \\
+\hline
+© ?%?( (int)li, i )©                                                                            & (unsafe)      & 6     \\
+© ?%?( (unsigned)li,(unsigned)i )©                                                      & (unsafe)      & 5     \\
+© ?%?( li, (long)i )©                                                                           & 1                     & 4     \\
+© ?%?( (long unsigned)li,(long unsigned)i )©                            & 3                     & 3     \\
+© ?%?( (long long)li,(long long)i )©                                            & 5                     & 2     \\
+© ?%?( (long long unsigned)li, (long long unsigned)i )©         & 7                     & 1     \\
 \end{tabular}
 \end{center}
+The best interpretation of \lstinline$eat_double( li, i )$ is
+\lstinline$eat_double( (double)?%?(li, (long)i ))$, which has no unsafe conversions and the lowest total cost.
+\begin{rationale}
+{\c11} defines most arithmetic operations to apply an \Index{integer promotion} to any argument that belongs to a type that has an \Index{integer conversion rank} less than that of \lstinline$int$.If
+\lstinline$s$ is a \lstinline$short int$, ``\lstinline$s *s$'' does not have type \lstinline$short int$;
+it is treated as ``\lstinline$( (int)s ) * ( (int)s )$'', and has type \lstinline$int$. \CFA matches that pattern;
+it does not predefine ``\lstinline$short ?*?( short, short )$''.
+The best interpretation of ©eat_double( li, i )© is ©eat_double( (double)?%?(li, (long)i ))©, which has no unsafe conversions and the lowest total cost.
+\begin{rationale}
+{\c11} defines most arithmetic operations to apply an \Index{integer promotion} to any argument that belongs to a type that has an \Index{integer conversion rank} less than that of ©int©.
+If ©s© is a ©short int©, ``©s *s©'' does not have type ©short int©;
+it is treated as ``©( (int)s ) * ( (int)s )©'', and has type ©int©. \CFA matches that pattern;
+it does not predefine ``©short ?*?( short, short )©''.
 These ``missing'' operators limit polymorphism.
 …
 square( s );
 \end{lstlisting}
+Since \CFA does not define a multiplication operator for \lstinline$short int$,
+\lstinline$square( s )$ is treated as \lstinline$square( (int)s )$, and the result has type
+\lstinline$int$.
+Since \CFA does not define a multiplication operator for ©short int©, ©square( s )© is treated as ©square( (int)s )©, and the result has type ©int©.
 This is mildly surprising, but it follows the {\c11} operator pattern.
 …
 product( sa, 5);
 \end{lstlisting}
+This has no valid interpretations, because \CFA has no conversion from ``array of
+\lstinline$short int$'' to ``array of \lstinline$int$''.
+This has no valid interpretations, because \CFA has no conversion from ``array of ©short int©'' to ``array of ©int©''.
 The alternatives in such situations include
 \begin{itemize}
 \item
+Defining monomorphic overloadings of \lstinline$product$ for \lstinline$short$ and the other
+``small'' types.
+\item
+Defining ``\lstinline$short ?*?( short, short )$'' within the scope containing the call to
+\lstinline$product$.
+\item
+Defining \lstinline$product$ to take as an argument a conversion function from the ``small'' type to the operator's argument type.
+Defining monomorphic overloadings of ©product© for ©short© and the other ``small'' types.
+\item
+Defining ``©short ?*?( short, short )©'' within the scope containing the call to ©product©.
+\item
+Defining ©product© to take as an argument a conversion function from the ``small'' type to the operator's argument type.
 \end{itemize}
 \end{rationale}
 …
 \lhs{additive-expression}
 \rhs \nonterm{multiplicative-expression}
 \rhs \nonterm{additive-expression} \lstinline$+$ \nonterm{multiplicative-expression}
 \rhs \nonterm{additive-expression} \lstinline$-$ \nonterm{multiplicative-expression}
+\rhs \nonterm{additive-expression} ©+© \nonterm{multiplicative-expression}
+\rhs \nonterm{additive-expression} ©-© \nonterm{multiplicative-expression}
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 a + b @\rewrite@ ?+?( a, b )@\use{?+?}@
 a - b @\rewrite@ ?-?( a, b )@\use{?-?}@
+a + b => ?+?( a, b )§\use{?+?}§
+a - b => ?-?( a, b )§\use{?-?}§
 \end{lstlisting}
 …
         * ?-?( _Atomic const restrict volatile T *, _Atomic const restrict volatile T * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \begin{rationale}
 \lstinline$ptrdiff_t$ is an implementation-defined identifier defined in \lstinline$<stddef.h>$ that is synonymous with a signed integral type that is large enough to hold the difference between two pointers.
+©ptrdiff_t© is an implementation-defined identifier defined in ©<stddef.h>© that is synonymous with a signed integral type that is large enough to hold the difference between two pointers.
 It seems reasonable to use it for pointer addition as well. (This is technically a difference between \CFA and C, which only specifies that pointer addition uses an \emph{integral} argument.) Hence it is also used for subscripting, which is defined in terms of pointer addition.
 The {\c11} standard uses \lstinline$size_t$ in several cases where a library function takes an argument that is used as a subscript, but \lstinline$size_t$ is unsuitable here because it is an unsigned type.
+The {\c11} standard uses ©size_t© in several cases where a library function takes an argument that is used as a subscript, but ©size_t© is unsuitable here because it is an unsigned type.
 \end{rationale}
 …
 \lhs{shift-expression}
 \rhs \nonterm{additive-expression}
 \rhs \nonterm{shift-expression} \lstinline$<<$ \nonterm{additive-expression}
 \rhs \nonterm{shift-expression} \lstinline$>>$ \nonterm{additive-expression}
+\rhs \nonterm{shift-expression} ©<<© \nonterm{additive-expression}
+\rhs \nonterm{shift-expression} ©>>© \nonterm{additive-expression}
 \end{syntax}
 \rewriterules \use{?>>?}%use{?<<?}
 \begin{lstlisting}
 a << b @\rewrite@ ?<<?( a, b )
 a >> b @\rewrite@ ?>>?( a, b )
+\rewriterules
+\begin{lstlisting}
+a << b => ?<<?( a, b )§\use{?<<?}§
+a >> b => ?>>?( a, b )§\use{?>>?}§
 \end{lstlisting}
 …
 long long unsigned int ?<<?( long long unsigned int, int ), ?>>?( long long unsigned int, int);
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{relational-expression}
 \rhs \nonterm{shift-expression}
 \rhs \nonterm{relational-expression} \lstinline$< $ \nonterm{shift-expression}
 \rhs \nonterm{relational-expression} \lstinline$> $ \nonterm{shift-expression}
 \rhs \nonterm{relational-expression} \lstinline$<=$ \nonterm{shift-expression}
 \rhs \nonterm{relational-expression} \lstinline$>=$ \nonterm{shift-expression}
+\rhs \nonterm{relational-expression} ©< © \nonterm{shift-expression}
+\rhs \nonterm{relational-expression} ©> © \nonterm{shift-expression}
+\rhs \nonterm{relational-expression} ©<=© \nonterm{shift-expression}
+\rhs \nonterm{relational-expression} ©>=© \nonterm{shift-expression}
 \end{syntax}
 \rewriterules\use{?>?}\use{?>=?}%use{?<?}%use{?<=?}
 \begin{lstlisting}
 a < b @\rewrite@ ?<?( a, b )
 a > b @\rewrite@ ?>?( a, b )
 a <= b @\rewrite@ ?<=?( a, b )
 a >= b @\rewrite@ ?>=?( a, b )
+\rewriterules
+\begin{lstlisting}
+a < b => ?<?( a, b )§\use{?<?}§
+a > b => ?>?( a, b )§\use{?>?}§
+a <= b => ?<=?( a, b )§\use{?<=?}§
+a >= b => ?>=?( a, b )§\use{?>=?}§
 \end{lstlisting}
 …
         ?>=?( _Atomic const restrict volatile DT *, _Atomic const restrict volatile DT * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{equality-expression}
 \rhs \nonterm{relational-expression}
 \rhs \nonterm{equality-expression} \lstinline$==$ \nonterm{relational-expression}
 \rhs \nonterm{equality-expression} \lstinline$!=$ \nonterm{relational-expression}
+\rhs \nonterm{equality-expression} ©==© \nonterm{relational-expression}
+\rhs \nonterm{equality-expression} ©!=© \nonterm{relational-expression}
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 a == b @\rewrite@ ?==?( a, b )@\use{?==?}@
 a != b @\rewrite@ ?!=?( a, b )@\use{?"!=?}@
+a == b => ?==?( a, b )§\use{?==?}§
+a != b => ?!=?( a, b )§\use{?"!=?}§
 \end{lstlisting}
 …
         ?==?( forall( ftype FT2) FT2*, forall( ftype FT3) FT3 * ), ?!=?( forall( ftype FT2) FT2*, forall( ftype FT3) FT3 * );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \begin{rationale}
 The polymorphic equality operations come in three styles: comparisons between pointers of compatible types, between pointers to \lstinline$void$ and pointers to object types or incomplete types, and between the \Index{null pointer} constant and pointers to any type.
+The polymorphic equality operations come in three styles: comparisons between pointers of compatible types, between pointers to ©void© and pointers to object types or incomplete types, and between the \Index{null pointer} constant and pointers to any type.
 In the last case, a special constraint rule for null pointer constant operands has been replaced by a consequence of the \CFA type system.
 \end{rationale}
 …
 \lhs{AND-expression}
 \rhs \nonterm{equality-expression}
 \rhs \nonterm{AND-expression} \lstinline$&$ \nonterm{equality-expression}
+\rhs \nonterm{AND-expression} ©&© \nonterm{equality-expression}
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 a & b @\rewrite@ ?&?( a, b )@\use{?&?}@
+a & b => ?&?( a, b )§\use{?&?}§
 \end{lstlisting}
 …
 long long unsigned int ?&?( long long unsigned int, long long unsigned int );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{exclusive-OR-expression}
 \rhs \nonterm{AND-expression}
 \rhs \nonterm{exclusive-OR-expression} \lstinline$^$ \nonterm{AND-expression}
+\rhs \nonterm{exclusive-OR-expression} ©^© \nonterm{AND-expression}
 \end{syntax}
 \rewriterules
 \begin{lstlisting}
 a ^ b @\rewrite@ ?^?( a, b )@\use{?^?}@
+a ^ b => ?^?( a, b )§\use{?^?}§
 \end{lstlisting}
 …
 long long unsigned int ?^?( long long unsigned int, long long unsigned int );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{inclusive-OR-expression}
 \rhs \nonterm{exclusive-OR-expression}
 \rhs \nonterm{inclusive-OR-expression} \lstinline$|$ \nonterm{exclusive-OR-expression}
+\rhs \nonterm{inclusive-OR-expression} ©|© \nonterm{exclusive-OR-expression}
 \end{syntax}
 \rewriterules\use{?"|?}
 \begin{lstlisting}
 a | b @\rewrite@ ?|?( a, b )
+\rewriterules
+\begin{lstlisting}
+a | b => ?|?( a, b )§\use{?"|?}§
 \end{lstlisting}
 …
 long long unsigned int ?|?( long long unsigned int, long long unsigned int );
 \end{lstlisting}
 For every extended integer type \lstinline$X$ with \Index{integer conversion rank} greater than the rank of \lstinline$int$ there exist
+For every extended integer type ©X© with \Index{integer conversion rank} greater than the rank of ©int© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{logical-AND-expression}
 \rhs \nonterm{inclusive-OR-expression}
 \rhs \nonterm{logical-AND-expression} \lstinline$&&$ \nonterm{inclusive-OR-expression}
+\rhs \nonterm{logical-AND-expression} ©&&© \nonterm{inclusive-OR-expression}
 \end{syntax}
+\semantics The operands of the expression ``\lstinline$a && b$'' are treated as
+``\lstinline$(int)((a)!=0)$'' and ``\lstinline$(int)((b)!=0)$'', which shall both be unambiguous.
+The expression has only one interpretation, which is of type \lstinline$int$.
+\begin{rationale}
+When the operands of a logical expression are values of built-in types, and ``\lstinline$!=$'' has not been redefined for those types, the compiler can optimize away the function calls.
+A common C idiom omits comparisons to \lstinline$0$ in the controlling expressions of loops and
+\lstinline$if$ statements.
+For instance, the loop below iterates as long as \lstinline$rp$ points at a \lstinline$Rational$ value that is non-zero.
+\begin{lstlisting}
+extern otype Rational;@\use{Rational}@
+extern const Rational 0;@\use{0}@
+\semantics The operands of the expression ``©a && b©'' are treated as ``©(int)((a)!=0)©'' and ``©(int)((b)!=0)©'', which shall both be unambiguous.
+The expression has only one interpretation, which is of type ©int©.
+\begin{rationale}
+When the operands of a logical expression are values of built-in types, and ``©!=©'' has not been redefined for those types, the compiler can optimize away the function calls.
+A common C idiom omits comparisons to ©0© in the controlling expressions of loops and ©if© statements.
+For instance, the loop below iterates as long as ©rp© points at a ©Rational© value that is non-zero.
+\begin{lstlisting}
+extern otype Rational;§\use{Rational}§
+extern const Rational 0;§\use{0}§
 extern int ?!=?( Rational, Rational );
 Rational *rp;
 while ( rp && *rp ) { ... }
 \end{lstlisting}
 The logical expression calls the \lstinline$Rational$ inequality operator, passing it \lstinline$*rp$ and the \lstinline$Rational 0$, and getting a 1 or 0 as a result.
 In contrast, {\CC} would apply a programmer-defined \lstinline$Rational$-to-\lstinline$int$ conversion to \lstinline$*rp$ in the equivalent situation.
 The conversion to \lstinline$int$ would produce a general integer value, which is unfortunate, and possibly dangerous if the conversion was not written with this situation in mind.
+The logical expression calls the ©Rational© inequality operator, passing it ©*rp© and the ©Rational 0©, and getting a 1 or 0 as a result.
+In contrast, {\CC} would apply a programmer-defined ©Rational©-to-©int© conversion to ©*rp© in the equivalent situation.
+The conversion to ©int© would produce a general integer value, which is unfortunate, and possibly dangerous if the conversion was not written with this situation in mind.
 \end{rationale}
 …
 \lhs{logical-OR-expression}
 \rhs \nonterm{logical-AND-expression}
 \rhs \nonterm{logical-OR-expression} \lstinline$||$ \nonterm{logical-AND-expression}
+\rhs \nonterm{logical-OR-expression} ©||© \nonterm{logical-AND-expression}
 \end{syntax}
 \semantics
 The operands of the expression ``\lstinline$a || b$'' are treated as ``\lstinline$(int)((a)!=0)$'' and ``\lstinline$(int)((b))!=0)$'', which shall both be unambiguous.
 The expression has only one interpretation, which is of type \lstinline$int$.
+The operands of the expression ``©a || b©'' are treated as ``©(int)((a)!=0)©'' and ``©(int)((b))!=0)©'', which shall both be unambiguous.
+The expression has only one interpretation, which is of type ©int©.
 …
 \lhs{conditional-expression}
 \rhs \nonterm{logical-OR-expression}
 \rhs \nonterm{logical-OR-expression} \lstinline$?$ \nonterm{expression}
          \lstinline$:$ \nonterm{conditional-expression}
+\rhs \nonterm{logical-OR-expression} ©?© \nonterm{expression}
+         ©:© \nonterm{conditional-expression}
 \end{syntax}
 \semantics
 In the conditional expression\use{?:} ``\lstinline$a?b:c$'', if the second and third operands both have an interpretation with \lstinline$void$ type, then the expression has an interpretation with type \lstinline$void$, equivalent to
+In the conditional expression\use{?:} ``©a?b:c©'', if the second and third operands both have an interpretation with ©void© type, then the expression has an interpretation with type ©void©, equivalent to
 \begin{lstlisting}
 ( int)(( a)!=0) ? ( void)( b) : ( void)( c)
 \end{lstlisting}
 If the second and third operands both have interpretations with non-\lstinline$void$ types, the expression is treated as if it were the call ``\lstinline$cond((a)!=0, b, c)$'', with \lstinline$cond$ declared as
+If the second and third operands both have interpretations with non-©void© types, the expression is treated as if it were the call ``©cond((a)!=0, b, c)©'', with ©cond© declared as
 \begin{lstlisting}
 forall( otype T ) T cond( int, T, T );
 …
 rand() ? i : l;
 \end{lstlisting}
+The best interpretation infers the expression's type to be \lstinline$long$ and applies the safe
+\lstinline$int$-to-\lstinline$long$ conversion to \lstinline$i$.
+The best interpretation infers the expression's type to be ©long© and applies the safe ©int©-to-©long© conversion to ©i©.
 \begin{lstlisting}
 …
 rand() ? cip : vip;
 \end{lstlisting}
 The expression has type \lstinline$const volatile int *$, with safe conversions applied to the second and third operands to add \lstinline$volatile$ and \lstinline$const$ qualifiers, respectively.
+The expression has type ©const volatile int *©, with safe conversions applied to the second and third operands to add ©volatile© and ©const© qualifiers, respectively.
 \begin{lstlisting}
 rand() ? cip : 0;
 \end{lstlisting}
+The expression has type \lstinline$const int *$, with a specialization conversion applied to
+\lstinline$0$.
+The expression has type ©const int *©, with a specialization conversion applied to ©0©.
 …
          \nonterm{assignment-expression}
 \lhs{assignment-operator} one of
+\rhs \lstinline$=$\ \ \lstinline$*=$\ \ \lstinline$/=$\ \ \lstinline$%=$\ \ \lstinline$+=$\ \ \lstinline$-=$\ \
+         \lstinline$<<=$\ \ \lstinline$>>=$\ \ \lstinline$&=$\ \ \lstinline$^=$\ \ \lstinline$|=$
+\rhs ©=©\ \ ©*=©\ \ ©/=©\ \ ©%=©\ \ ©+=©\ \ ©-=©\ \ ©<<=©\ \ ©>>=©\ \ ©&=©\ \ ©^=©\ \ ©|=©
 \end{syntax}
 \rewriterules
 Let ``\(\leftarrow\)'' be any of the assignment operators.
+Let ``©<-©'' be any of the assignment operators.
 Then
+\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}
+\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
+\begin{lstlisting}
+a @$\leftarrow$@ b @\rewrite@ ?@$\leftarrow$@?( &( a ), b )
+\use{?=?}\use{?*=?}\use{?/=?}\use{?%=?}\use{?+=?}\use{?-=?}\use{?>>=?}\use{?&=?}\use{?^=?}\use{?"|=?}%use{?<<=?}
+\begin{lstlisting}
+a <- b => ?<-?( &( a ), b )
 \end{lstlisting}
 \semantics
 Each interpretation of the left operand of an assignment expression is considered separately.
 For each interpretation that is a bit-field or is declared with the \lstinline$register$ storage class specifier, the expression has one valid interpretation, with the type of the left operand.
+For each interpretation that is a bit-field or is declared with the ©register© storage class specifier, the expression has one valid interpretation, with the type of the left operand.
 The right operand is cast to that type, and the assignment expression is ambiguous if either operand is.
 For the remaining interpretations, the expression is rewritten, and the interpretations of the assignment expression are the interpretations of the corresponding function call.
 …
 \end{lstlisting}
 \begin{rationale}
 The pattern of overloadings for simple assignment resembles that of pointer increment and decrement, except that the polymorphic pointer assignment functions declare a \lstinline$dtype$ parameter, instead of a \lstinline$type$ parameter, because the left operand may be a pointer to an incomplete type.
 \end{rationale}
 For every complete structure or union type \lstinline$S$ there exist
+The pattern of overloadings for simple assignment resembles that of pointer increment and decrement, except that the polymorphic pointer assignment functions declare a ©dtype© parameter, instead of a ©type© parameter, because the left operand may be a pointer to an incomplete type.
+\end{rationale}
+For every complete structure or union type ©S© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \end{lstlisting}
 For every extended integer type \lstinline$X$ there exist
+For every extended integer type ©X© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \end{lstlisting}
 For every complete enumerated type \lstinline$E$ there exist
+For every complete enumerated type ©E© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \end{lstlisting}
 \begin{rationale}
 The right-hand argument is \lstinline$int$ because enumeration constants have type \lstinline$int$.
+The right-hand argument is ©int© because enumeration constants have type ©int©.
 \end{rationale}
 …
 \end{lstlisting}
 For every extended integer type \lstinline$X$ there exist
+For every extended integer type ©X© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \end{lstlisting}
 For every complete enumerated type \lstinline$E$ there exist
+For every complete enumerated type ©E© there exist
 % Don't use predefined: keep this out of prelude.cf.
 \begin{lstlisting}
 …
 \lhs{expression}
 \rhs \nonterm{assignment-expression}
 \rhs \nonterm{expression} \lstinline$,$ \nonterm{assignment-expression}
+\rhs \nonterm{expression} ©,© \nonterm{assignment-expression}
 \end{syntax}
 \semantics
+In the comma expression ``\lstinline$a, b$'', the first operand is interpreted as
+``\lstinline$( void )(a)$'', which shall be unambiguous\index{ambiguous interpretation}.
+In the comma expression ``©a, b©'', the first operand is interpreted as ``©( void )(a)©'', which shall be unambiguous\index{ambiguous interpretation}.
 The interpretations of the expression are the interpretations of the second operand.
 …
 { ... }
 \end{lstlisting}
 Without the rule, \lstinline$Complex$ would be a type in the first case, and a parameter name in the second.
+Without the rule, ©Complex© would be a type in the first case, and a parameter name in the second.
 \end{rationale}
 …
 \examples
 \begin{lstlisting}
 struct point {@\impl{point}@
+struct point {§\impl{point}§
         int x, y;
 };
 struct color_point {@\impl{color_point}@
+struct color_point {§\impl{color_point}§
         enum { RED, BLUE, GREEN } color;
         struct point;
 …
 cp.x = 0;
 cp.color = RED;
 struct literal {@\impl{literal}@
+struct literal {§\impl{literal}§
         enum { NUMBER, STRING } tag;
         union {
 …
 \begin{syntax}
 \lhs{forall-specifier}
 \rhs \lstinline$forall$ \lstinline$($ \nonterm{type-parameter-list} \lstinline$)$
+\rhs ©forall© ©(© \nonterm{type-parameter-list} ©)©
 \end{syntax}
 …
 } mkPair( T, T ); // illegal
 \end{lstlisting}
 If an instance of \lstinline$struct Pair$ was declared later in the current scope, what would the members' type be?
+If an instance of ©struct Pair© was declared later in the current scope, what would the members' type be?
 \end{rationale}
 \end{comment}
 …
 The \nonterm{type-parameter-list}s and assertions of the \nonterm{forall-specifier}s declare type identifiers, function and object identifiers with \Index{no linkage}.
+If, in the declaration ``\lstinline$T D$'', \lstinline$T$ contains \nonterm{forall-specifier}s and
+\lstinline$D$ has the form
+\begin{lstlisting}
+D( @\normalsize\nonterm{parameter-type-list}@ )
+\end{lstlisting} then a type identifier declared by one of the \nonterm{forall-specifier}s is an \define{inferred parameter} of the function declarator if and only if it is not an inferred parameter of a function declarator in \lstinline$D$, and it is used in the type of a parameter in the following
+\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a
+\Index{specification} in one of the \nonterm{forall-specifier}s.
+If, in the declaration ``©T D©'', ©T© contains \nonterm{forall-specifier}s and ©D© has the form
+\begin{lstlisting}
+D( §\normalsize\nonterm{parameter-type-list}§ )
+\end{lstlisting} then a type identifier declared by one of the \nonterm{forall-specifier}s is an \define{inferred parameter} of the function declarator if and only if it is not an inferred parameter of a function declarator in ©D©, and it is used in the type of a parameter in the following
+\nonterm{type-parameter-list} or it and an inferred parameter are used as arguments of a \Index{specification} in one of the \nonterm{forall-specifier}s.
 The identifiers declared by assertions that use an inferred parameter of a function declarator are \Index{assertion parameter}s of that function declarator.
 …
 If this restriction were lifted, it would be possible to write
 \begin{lstlisting}
+forall( otype T ) T * alloc( void );@\use{alloc}@ int *p = alloc();
+\end{lstlisting}
+Here \lstinline$alloc()$ would receive \lstinline$int$ as an inferred argument, and return an
+\lstinline$int *$.
+In general, if a call to \lstinline$alloc()$ is a subexpression of an expression involving polymorphic functions and overloaded identifiers, there could be considerable distance between the call and the subexpression that causes \lstinline$T$ to be bound.
+With the current restriction, \lstinline$alloc()$ must be given an argument that determines
+\lstinline$T$:
+\begin{lstlisting}
+forall( otype T ) T * alloc( T initial_value );@\use{alloc}@
+forall( otype T ) T * alloc( void );§\use{alloc}§ int *p = alloc();
+\end{lstlisting}
+Here ©alloc()© would receive ©int© as an inferred argument, and return an ©int *©.
+In general, if a call to ©alloc()© is a subexpression of an expression involving polymorphic functions and overloaded identifiers, there could be considerable distance between the call and the subexpression that causes ©T© to be bound.
+With the current restriction, ©alloc()© must be given an argument that determines ©T©:
+\begin{lstlisting}
+forall( otype T ) T * alloc( T initial_value );§\use{alloc}§
 \end{lstlisting}
 \end{rationale}
 …
 If a function declarator is part of a function definition, its inferred parameters and assertion parameters have \Index{block scope};
+otherwise, identifiers declared by assertions have a
+\define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
+otherwise, identifiers declared by assertions have a \define{declaration scope}, which terminates at the end of the \nonterm{declaration}.
 A function type that has at least one inferred parameter is a \define{polymorphic function} type.
 …
 Let $f$ and $g$ be two polymorphic function types with the same number of inferred parameters, and let $f_i$ and $g_i$ be the inferred parameters of $f$ and $g$ in their order of occurance in the function types' \nonterm{parameter-type-list}s.
 Let $f'$ be $f$ with every occurrence of $f_i$ replaced by $g_i$, for all $i$.
+Then $f$ and $g$ are
+\Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
+Then $f$ and $g$ are \Index{compatible type}s if $f'$'s and $g$'s return types and parameter lists are compatible, and if for every assertion parameter of $f'$ there is an assertion parameter in $g$ with the same identifier and compatible type, and vice versa.
 \examples
 …
 forall( otype T ) T fT( T );
 \end{lstlisting}
+\lstinline$fi()$ takes an \lstinline$int$ and returns an \lstinline$int$. \lstinline$fT()$ takes a
+\lstinline$T$ and returns a \lstinline$T$, for any type \lstinline$T$.
+©fi()© takes an ©int© and returns an ©int©. ©fT()© takes a ©T© and returns a ©T©, for any type ©T©.
 \begin{lstlisting}
 int (*pfi )( int ) = fi;
 forall( otype T ) T (*pfT )( T ) = fT;
 \end{lstlisting}
 \lstinline$pfi$ and \lstinline$pfT$ are pointers to functions. \lstinline$pfT$ is not polymorphic, but the function it points at is.
+©pfi© and ©pfT© are pointers to functions. ©pfT© is not polymorphic, but the function it points at is.
 \begin{lstlisting}
 int (*fvpfi( void ))( int ) {
 …
+}
 \end{lstlisting}
 \lstinline$fvpfi()$ and \lstinline$fvpfT()$ are functions taking no arguments and returning pointers to functions. \lstinline$fvpfT()$ is monomorphic, but the function that its return value points at is polymorphic.
+©fvpfi()© and ©fvpfT()© are functions taking no arguments and returning pointers to functions. ©fvpfT()© is monomorphic, but the function that its return value points at is polymorphic.
 \begin{lstlisting}
 forall( otype T ) int ( *fTpfi( T ) )( int );
 …
 forall( otype T, otype U ) U ( *fTpfU( T ) )( U );
 \end{lstlisting}
+\lstinline$fTpfi()$ is a polymorphic function that returns a pointer to a monomorphic function taking an integer and returning an integer.
+It could return \lstinline$pfi$. \lstinline$fTpfT()$ is subtle: it is a polymorphic function returning a \emph{monomorphic} function taking and returning
+\lstinline$T$, where \lstinline$T$ is an inferred parameter of \lstinline$fTpfT()$.
+For instance, in the expression ``\lstinline$fTpfT(17)$'', \lstinline$T$ is inferred to be \lstinline$int$, and the returned value would have type \lstinline$int ( * )( int )$. ``\lstinline$fTpfT(17)(13)$'' and
+``\lstinline$fTpfT("yes")("no")$'' are legal, but ``\lstinline$fTpfT(17)("no")$'' is illegal.
+\lstinline$fTpfU()$ is polymorphic ( in type \lstinline$T$), and returns a pointer to a function that is polymorphic ( in type \lstinline$U$). ``\lstinline$f5(17)("no")$'' is a legal expression of type
+\lstinline$char *$.
+©fTpfi()© is a polymorphic function that returns a pointer to a monomorphic function taking an integer and returning an integer.
+It could return ©pfi©. ©fTpfT()© is subtle: it is a polymorphic function returning a \emph{monomorphic} function taking and returning
+©T©, where ©T© is an inferred parameter of ©fTpfT()©.
+For instance, in the expression ``©fTpfT(17)©'', ©T© is inferred to be ©int©, and the returned value would have type ©int ( * )( int )©. ``©fTpfT(17)(13)©'' and ``©fTpfT("yes")("no")©'' are legal, but ``©fTpfT(17)("no")©'' is illegal.
+©fTpfU()© is polymorphic ( in type ©T©), and returns a pointer to a function that is polymorphic ( in type ©U©). ``©f5(17)("no")©'' is a legal expression of type ©char *©.
 \begin{lstlisting}
 forall( otype T, otype U, otype V ) U * f( T *, U, V * const );
 forall( otype U, otype V, otype W ) U * g( V *, U, W * const );
 \end{lstlisting}
 The functions \lstinline$f()$ and \lstinline$g()$ have compatible types.
+The functions ©f()© and ©g()© have compatible types.
 Let \(f\) and \(g\) be their types;
 then \(f_1\) = \lstinline$T$, \(f_2\) = \lstinline$U$, \(f_3\) = \lstinline$V$, \(g_1\)
 = \lstinline$V$, \(g_2\) = \lstinline$U$, and \(g_3\) = \lstinline$W$.
+then \(f_1\) = ©T©, \(f_2\) = ©U©, \(f_3\) = ©V©, \(g_1\)
+= ©V©, \(g_2\) = ©U©, and \(g_3\) = ©W©.
 Replacing every \(f_i\) by \(g_i\) in \(f\) gives
 \begin{lstlisting}
 …
 \end{lstlisting} which has a return type and parameter list that is compatible with \(g\).
 \begin{rationale}
 The word ``\lstinline$type$'' in a forall specifier is redundant at the moment, but I want to leave room for inferred parameters of ordinary types in case parameterized types get added one day.
+The word ``©type©'' in a forall specifier is redundant at the moment, but I want to leave room for inferred parameters of ordinary types in case parameterized types get added one day.
 Even without parameterized types, I might try to allow
 …
 \subsection{Type qualifiers}
 \CFA defines a new type qualifier \lstinline$lvalue$\impl{lvalue}\index{lvalue}.
+\CFA defines a new type qualifier ©lvalue©\impl{lvalue}\index{lvalue}.
 \begin{syntax}
 \oldlhs{type-qualifier}
 \rhs \lstinline$lvalue$
+\rhs ©lvalue©
 \end{syntax}
 \constraints
 \lstinline$restrict$\index{register@{\lstinline$restrict$}} Types other than type parameters and pointer types whose referenced type is an object type shall not be restrict-qualified.
+\Indexc{restrict} Types other than type parameters and pointer types whose referenced type is an object type shall not be restrict-qualified.
 \semantics
+An object's type may be a restrict-qualified type parameter. \lstinline$restrict$ does not establish any special semantics in that case.
+An object's type may be a restrict-qualified type parameter.
+©restrict© does not establish any special semantics in that case.
 \begin{rationale}
 …
 \end{rationale}
+\lstinline$lvalue$ may be used to qualify the return type of a function type.
+Let \lstinline$T$ be an unqualified version of a type;
+then the result of calling a function with return type
+\lstinline$lvalue T$ is a \Index{modifiable lvalue} of type \lstinline$T$.
+\lstinline$const$\use{const} and \lstinline$volatile$\use{volatile} qualifiers may also be added to indicate that the function result is a constant or volatile lvalue.
+\begin{rationale}
+The \lstinline$const$ and \lstinline$volatile$ qualifiers can only be sensibly used to qualify the return type of a function if the \lstinline$lvalue$ qualifier is also used.
+©lvalue© may be used to qualify the return type of a function type.
+Let ©T© be an unqualified version of a type;
+then the result of calling a function with return type ©lvalue T© is a \Index{modifiable lvalue} of type ©T©.
+©const©\use{const} and ©volatile©\use{volatile} qualifiers may also be added to indicate that the function result is a constant or volatile lvalue.
+\begin{rationale}
+The ©const© and ©volatile© qualifiers can only be sensibly used to qualify the return type of a function if the ©lvalue© qualifier is also used.
 \end{rationale}
 …
 \begin{rationale}
 \lstinline$lvalue$ provides some of the functionality of {\CC}'s ``\lstinline$T&$'' ( reference to object of type \lstinline$T$) type.
+©lvalue© provides some of the functionality of {\CC}'s ``©T&©'' ( reference to object of type ©T©) type.
 Reference types have four uses in {\CC}.
 \begin{itemize}
 \item
+They are necessary for user-defined operators that return lvalues, such as ``subscript'' and
+``dereference''.
+\item
+A reference can be used to define an alias for a complicated lvalue expression, as a way of getting some of the functionality of the Pascal \lstinline$with$ statement.
+They are necessary for user-defined operators that return lvalues, such as ``subscript'' and ``dereference''.
+\item
+A reference can be used to define an alias for a complicated lvalue expression, as a way of getting some of the functionality of the Pascal ©with© statement.
 The following {\CC} code gives an example.
 \begin{lstlisting}
 …
 A reference parameter can be used to allow a function to modify an argument without forcing the caller to pass the address of the argument.
 This is most useful for user-defined assignment operators.
 In {\CC}, plain assignment is done by a function called ``\lstinline$operator=$'', and the two expressions
+In {\CC}, plain assignment is done by a function called ``©operator=©'', and the two expressions
 \begin{lstlisting}
 a = b;
 operator=( a, b );
 \end{lstlisting} are equivalent.
+If \lstinline$a$ and \lstinline$b$ are of type \lstinline$T$, then the first parameter of \lstinline$operator=$ must have type ``\lstinline$T&$''.
+It cannot have type
+\lstinline$T$, because then assignment couldn't alter the variable, and it can't have type
+``\lstinline$T *$'', because the assignment would have to be written ``\lstinline$&a = b;$''.
+In the case of user-defined operators, this could just as well be handled by using pointer types and by changing the rewrite rules so that ``\lstinline$a = b;$'' is equivalent to
+``\lstinline$operator=(&( a), b )$''.
+Reference parameters of ``normal'' functions are Bad Things, because they remove a useful property of C function calls: an argument can only be modified by a function if it is preceded by ``\lstinline$&$''.
+If ©a© and ©b© are of type ©T©, then the first parameter of ©operator=© must have type ``©T&©''.
+It cannot have type ©T©, because then assignment couldn't alter the variable, and it can't have type ``©T *©'', because the assignment would have to be written ``©&a = b;©''.
+In the case of user-defined operators, this could just as well be handled by using pointer types and by changing the rewrite rules so that ``©a = b;©'' is equivalent to ``©operator=(&( a), b )©''.
+Reference parameters of ``normal'' functions are Bad Things, because they remove a useful property of C function calls: an argument can only be modified by a function if it is preceded by ``©&©''.
 \item
 References to \Index{const-qualified} types can be used instead of value parameters.  Given the
 {\CC} function call ``\lstinline$fiddle( a_thing )$'', where the type of \lstinline$a_thing$ is
 \lstinline$Thing$, the type of \lstinline$fiddle$ could be either of
+{\CC} function call ``©fiddle( a_thing )©'', where the type of ©a_thing© is
+©Thing©, the type of ©fiddle© could be either of
 \begin{lstlisting}
 void fiddle( Thing );
 void fiddle( const Thing & );
 \end{lstlisting}
 If the second form is used, then constructors and destructors are not invoked to create a temporary variable at the call site ( and it is bad style for the caller to make any assumptions about such things), and within \lstinline$fiddle$ the parameter is subject to the usual problems caused by aliases.
 The reference form might be chosen for efficiency's sake if \lstinline$Thing$s are too large or their constructors or destructors are too expensive.
+If the second form is used, then constructors and destructors are not invoked to create a temporary variable at the call site ( and it is bad style for the caller to make any assumptions about such things), and within ©fiddle© the parameter is subject to the usual problems caused by aliases.
+The reference form might be chosen for efficiency's sake if ©Thing©s are too large or their constructors or destructors are too expensive.
 An implementation may switch between them without causing trouble for well-behaved clients.
 This leaves the implementor to define ``too large'' and ``too expensive''.
 …
 void fiddle( const volatile Thing );
 \end{lstlisting} with call-by-reference.
 Since it knows all about the size of \lstinline$Thing$s and the parameter passing mechanism, it should be able to come up with a better definition of ``too large'', and may be able to make a good guess at ``too expensive''.
+Since it knows all about the size of ©Thing©s and the parameter passing mechanism, it should be able to come up with a better definition of ``too large'', and may be able to make a good guess at ``too expensive''.
 \end{itemize}
 …
 \begin{syntax}
 \lhs{spec-definition}
 \rhs \lstinline$spec$ \nonterm{identifier}
         \lstinline$($ \nonterm{type-parameter-list} \lstinline$)$
         \lstinline${$ \nonterm{spec-declaration-list}\opt \lstinline$}$
+\rhs ©spec© \nonterm{identifier}
+        ©(© \nonterm{type-parameter-list} ©)©
+        ©{© \nonterm{spec-declaration-list}\opt ©}©
 \lhs{spec-declaration-list}
 \rhs \nonterm{spec-declaration} \lstinline$;$
 \rhs \nonterm{spec-declaration-list} \nonterm{spec-declaration} \lstinline$;$
+\rhs \nonterm{spec-declaration} ©;©
+\rhs \nonterm{spec-declaration-list} \nonterm{spec-declaration} ©;©
 \lhs{spec-declaration}
 \rhs \nonterm{specifier-qualifier-list} \nonterm{declarator-list}
 \lhs{declarator-list}
 \rhs \nonterm{declarator}
 \rhs \nonterm{declarator-list} \lstinline$,$ \nonterm{declarator}
+\rhs \nonterm{declarator-list} ©,© \nonterm{declarator}
 \end{syntax}
 \begin{rationale}
 …
 \rhs \nonterm{assertion-list} \nonterm{assertion}
 \lhs{assertion}
 \rhs \lstinline$|$ \nonterm{identifier} \lstinline$($ \nonterm{type-name-list} \lstinline$)$
 \rhs \lstinline$|$ \nonterm{spec-declaration}
+\rhs ©|© \nonterm{identifier} ©(© \nonterm{type-name-list} ©)©
+\rhs ©|© \nonterm{spec-declaration}
 \lhs{type-name-list}
 \rhs \nonterm{type-name}
 \rhs \nonterm{type-name-list} \lstinline$,$ \nonterm{type-name}
+\rhs \nonterm{type-name-list} ©,© \nonterm{type-name}
 \end{syntax}
 …
 The \nonterm{type-name-list} shall contain one \nonterm{type-name} argument for each \nonterm{type-parameter} in that specification's \nonterm{spec-parameter-list}.
 If the
 \nonterm{type-parameter} uses type-class \lstinline$type$\use{type}, the argument shall be the type name of an \Index{object type};
 if it uses \lstinline$dtype$, the argument shall be the type name of an object type or an \Index{incomplete type};
 and if it uses \lstinline$ftype$, the argument shall be the type name of a \Index{function type}.
+\nonterm{type-parameter} uses type-class ©type©\use{type}, the argument shall be the type name of an \Index{object type};
+if it uses ©dtype©, the argument shall be the type name of an object type or an \Index{incomplete type};
+and if it uses ©ftype©, the argument shall be the type name of a \Index{function type}.
 \semantics
+An \define{assertion} is a declaration of a collection of objects and functions, called
+\define{assertion parameters}.
+An \define{assertion} is a declaration of a collection of objects and functions, called \define{assertion parameters}.
 The assertion parameters produced by an assertion that applies the name of a specification to type arguments are found by taking the declarations specified in the specification and treating each of the specification's parameters as a synonym for the corresponding \nonterm{type-name} argument.
 …
 \examples
 \begin{lstlisting}
 forall( otype T | T ?*?( T, T ))@\use{?*?}@
 T square( T val ) {@\impl{square}@
+forall( otype T | T ?*?( T, T ))§\use{?*?}§
+T square( T val ) {§\impl{square}§
         return val + val;
+}
 trait summable( otype T ) {@\impl{summable}@
         T ?+=?( T *, T );@\use{?+=?}@
         const T 0;@\use{0}@
+trait summable( otype T ) {§\impl{summable}§
+        T ?+=?( T *, T );§\use{?+=?}§
+        const T 0;§\use{0}§
 };
 trait list_of( otype List, otype Element ) {@\impl{list_of}@
+trait list_of( otype List, otype Element ) {§\impl{list_of}§
         Element car( List );
         List cdr( List );
 …
 trait sum_list( otype List, otype Element | summable( Element ) | list_of( List, Element ) ) {};
 \end{lstlisting}
 \lstinline$sum_list$ contains seven declarations, which describe a list whose elements can be added up.
 The assertion ``\lstinline$|sum_list( i_list, int )$''\use{sum_list} produces the assertion parameters
+©sum_list© contains seven declarations, which describe a list whose elements can be added up.
+The assertion ``©|sum_list( i_list, int )©''\use{sum_list} produces the assertion parameters
 \begin{lstlisting}
 int ?+=?( int *, int );
 …
 \lhs{type-parameter-list}
 \rhs \nonterm{type-parameter}
 \rhs \nonterm{type-parameter-list} \lstinline$,$ \nonterm{type-parameter}
+\rhs \nonterm{type-parameter-list} ©,© \nonterm{type-parameter}
 \lhs{type-parameter}
 \rhs \nonterm{type-class} \nonterm{identifier} \nonterm{assertion-list}\opt
 \lhs{type-class}
 \rhs \lstinline$type$
 \rhs \lstinline$dtype$
 \rhs \lstinline$ftype$
+\rhs ©type©
+\rhs ©dtype©
+\rhs ©ftype©
 \lhs{type-declaration}
 \rhs \nonterm{storage-class-specifier}\opt \lstinline$type$ \nonterm{type-declarator-list} \verb|;|
+\rhs \nonterm{storage-class-specifier}\opt ©type© \nonterm{type-declarator-list} \verb|;|
 \lhs{type-declarator-list}
 \rhs \nonterm{type-declarator}
 \rhs \nonterm{type-declarator-list} \lstinline$,$ \nonterm{type-declarator}
+\rhs \nonterm{type-declarator-list} ©,© \nonterm{type-declarator}
 \lhs{type-declarator}
 \rhs \nonterm{identifier} \nonterm{assertion-list}\opt \lstinline$=$ \nonterm{type-name}
+\rhs \nonterm{identifier} \nonterm{assertion-list}\opt ©=© \nonterm{type-name}
 \rhs \nonterm{identifier} \nonterm{assertion-list}\opt
 \end{syntax}
 …
 An identifier declared by a \nonterm{type-parameter} has \Index{no linkage}.
+Identifiers declared with type-class \lstinline$type$\use{type} are \Index{object type}s;
+those declared with type-class
+\lstinline$dtype$\use{dtype} are \Index{incomplete type}s;
+and those declared with type-class
+\lstinline$ftype$\use{ftype} are \Index{function type}s.
+Identifiers declared with type-class ©type©\use{type} are \Index{object type}s;
+those declared with type-class ©dtype©\use{dtype} are \Index{incomplete type}s;
+and those declared with type-class ©ftype©\use{ftype} are \Index{function type}s.
 The identifier has \Index{block scope} that terminates at the end of the \nonterm{spec-declaration-list} or polymorphic function that contains the \nonterm{type-parameter}.
 …
 Within the scope of the declaration, \Index{implicit conversion}s can be performed between the defined type and the implementation type, and between pointers to the defined type and pointers to the implementation type.
+A type declaration without an \Index{initializer} and without a \Index{storage-class specifier} or with storage-class specifier \lstinline$static$\use{static} defines an \Index{incomplete type}.
+If a
+\Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
+A type declaration without an \Index{initializer} and without a \Index{storage-class specifier} or with storage-class specifier ©static©\use{static} defines an \Index{incomplete type}.
+If a \Index{translation unit} or \Index{block} contains one or more such declarations for an identifier, it must contain exactly one definition of the identifier ( but not in an enclosed block, which would define a new type known only within that block).
 \begin{rationale}
 Incomplete type declarations allow compact mutually-recursive types.
 …
 \end{rationale}
+A type declaration without an initializer and with \Index{storage-class specifier}
+\lstinline$extern$\use{extern} is an \define{opaque type declaration}.
+Opaque types are
+\Index{object type}s.
+A type declaration without an initializer and with \Index{storage-class specifier} ©extern©\use{extern} is an \define{opaque type declaration}.
+Opaque types are \Index{object type}s.
 An opaque type is not a \nonterm{constant-expression};
 neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.  Every other
 \Index{object type} is a \nonterm{constant-expression}.
+neither is a structure or union that has a member whose type is not a \nonterm{constant-expression}.
+Every other \Index{object type} is a \nonterm{constant-expression}.
 Objects with static storage duration shall be declared with a type that is a \nonterm{constant-expression}.
 \begin{rationale}
 …
 \end{rationale}
+An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a value of \Index{type-class} \lstinline$dtype$.
+An object type\index{object types} which is not a qualified version of a type is a value of type-classes \lstinline$type$ and \lstinline$dtype$.
+A
+\Index{function type} is a value of type-class \lstinline$ftype$.
+An \Index{incomplete type} which is not a qualified version\index{qualified type} of a type is a value of \Index{type-class} ©dtype©.
+An object type\index{object types} which is not a qualified version of a type is a value of type-classes ©type© and ©dtype©.
+A \Index{function type} is a value of type-class ©ftype©.
 \begin{rationale}
 Syntactically, a type value is a \nonterm{type-name}, which is a declaration for an object which omits the identifier being declared.
 …
 Type qualifiers are a weak point of C's type system.
+Consider the standard library function
+\lstinline$strchr()$ which, given a string and a character, returns a pointer to the first occurrence of the character in the string.
+\begin{lstlisting}
+char *strchr( const char *s, int c ) {@\impl{strchr}@
+Consider the standard library function ©strchr()© which, given a string and a character, returns a pointer to the first occurrence of the character in the string.
+\begin{lstlisting}
+char *strchr( const char *s, int c ) {§\impl{strchr}§
         char real_c = c; // done because c was declared as int.
         for ( ; *s != real_c; s++ )
 …
+}
 \end{lstlisting}
+The parameter \lstinline$s$ must be \lstinline$const char *$, because \lstinline$strchr()$ might be used to search a constant string, but the return type must be \lstinline$char *$, because the result might be used to modify a non-constant string.
+Hence the body must perform a cast, and ( even worse)
+\lstinline$strchr()$ provides a type-safe way to attempt to modify constant strings.
+What is needed is some way to say that \lstinline$s$'s type might contain qualifiers, and the result type has exactly the same qualifiers.
+The parameter ©s© must be ©const char *©, because ©strchr()© might be used to search a constant string, but the return type must be ©char *©, because the result might be used to modify a non-constant string.
+Hence the body must perform a cast, and ( even worse) ©strchr()© provides a type-safe way to attempt to modify constant strings.
+What is needed is some way to say that ©s©'s type might contain qualifiers, and the result type has exactly the same qualifiers.
 Polymorphic functions do not provide a fix for this deficiency\index{deficiencies!pointers to qualified types}, because type qualifiers are not part of type values.
 Instead, overloading can be used to define \lstinline$strchr()$ for each combination of qualifiers.
+Instead, overloading can be used to define ©strchr()© for each combination of qualifiers.
 \end{rationale}
 …
 };
 \end{lstlisting}
+Without this restriction, \CFA might require ``module initialization'' code ( since
+\lstinline$Rational$ has external linkage, it must be created before any other translation unit instantiates it), and would force an ordering on the initialization of the translation unit that defines \lstinline$Huge$ and the translation that declares \lstinline$Rational$.
+Without this restriction, \CFA might require ``module initialization'' code ( since ©Rational© has external linkage, it must be created before any other translation unit instantiates it), and would force an ordering on the initialization of the translation unit that defines ©Huge© and the translation that declares ©Rational©.
 A benefit of the restriction is that it prevents the declaration in separate translation units of types that contain each other, which would be hard to prevent otherwise.
 …
 //  File a.c:
         extern type t1;
         type t2 = struct { t1 f1; ... } // illegal
+        type t2 = struct { t1 f1; ... } // illegal
 //  File b.c:
         extern type t2;
         type t1 = struct { t2 f2; ... } // illegal
+        type t1 = struct { t2 f2; ... } // illegal
 \end{lstlisting}
 \end{rationale}
 …
 \nonterm{struct-declaration}, type declarations can not be structure members.
 The form of
 \nonterm{type-declaration} forbids arrays of, pointers to, and functions returning \lstinline$type$.
+\nonterm{type-declaration} forbids arrays of, pointers to, and functions returning ©type©.
 Hence the syntax of \nonterm{type-specifier} does not have to be extended to allow type-valued expressions.
 It also side-steps the problem of type-valued expressions producing different values in different declarations.
 …
 #include <stdlib.h>
 T * new( otype T ) { return ( T * )malloc( sizeof( T) ); };
 @\ldots@ int * ip = new( int );
 \end{lstlisting}
 This looks sensible, but \CFA's declaration-before-use rules mean that ``\lstinline$T$'' in the function body refers to the parameter, but the ``\lstinline$T$'' in the return type refers to the meaning of \lstinline$T$ in the scope that contains \lstinline$new$;
+... int * ip = new( int );
+\end{lstlisting}
+This looks sensible, but \CFA's declaration-before-use rules mean that ``©T©'' in the function body refers to the parameter, but the ``©T©'' in the return type refers to the meaning of ©T© in the scope that contains ©new©;
 it could be undefined, or a type name, or a function or variable name.
 Nothing good can result from such a situation.
 …
 f2( v2 );
 \end{lstlisting}
 \lstinline$V1$ is passed by value, so \lstinline$f1()$'s assignment to \lstinline$a[0]$ does not modify v1.  \lstinline$V2$ is converted to a pointer, so \lstinline$f2()$ modifies \lstinline$v2[0]$.
+©V1© is passed by value, so ©f1()©'s assignment to ©a[0]© does not modify v1.  ©V2© is converted to a pointer, so ©f2()© modifies ©v2[0]©.
 A translation unit containing the declarations
 \begin{lstlisting}
 extern type Complex;@\use{Complex}@ // opaque type declaration
 extern float abs( Complex );@\use{abs}@
 \end{lstlisting} can contain declarations of complex numbers, which can be passed to \lstinline$abs$.
 Some other translation unit must implement \lstinline$Complex$ and \lstinline$abs$.
+extern type Complex;§\use{Complex}§ // opaque type declaration
+extern float abs( Complex );§\use{abs}§
+\end{lstlisting} can contain declarations of complex numbers, which can be passed to ©abs©.
+Some other translation unit must implement ©Complex© and ©abs©.
 That unit might contain the declarations
 \begin{lstlisting}
 otype Complex = struct { float re, im; };@\impl{Complex}@
 Complex cplx_i = { 0.0, 1.0 };@\impl{cplx_i}@
 float abs( Complex c ) {@\impl{abs( Complex )}@
+otype Complex = struct { float re, im; };§\impl{Complex}§
+Complex cplx_i = { 0.0, 1.0 };§\impl{cplx_i}§
+float abs( Complex c ) {§\impl{abs( Complex )}§
         return sqrt( c.re * c.re + c.im * c.im );
+}
 \end{lstlisting}
 Note that \lstinline$c$ is implicitly converted to a \lstinline$struct$ so that its components can be retrieved.
 \begin{lstlisting}
 otype Time_of_day = int;@\impl{Time_of_day}@ // seconds since midnight.
 Time_of_day ?+?( Time_of_day t1, int seconds ) {@\impl{?+?}@
+Note that ©c© is implicitly converted to a ©struct© so that its components can be retrieved.
+\begin{lstlisting}
+otype Time_of_day = int;§\impl{Time_of_day}§ // seconds since midnight.
+Time_of_day ?+?( Time_of_day t1, int seconds ) {§\impl{?+?}§
         return (( int)t1 + seconds ) % 86400;
+}
 \end{lstlisting}
 \lstinline$t1$ must be cast to its implementation type to prevent infinite recursion.
+©t1© must be cast to its implementation type to prevent infinite recursion.
 \begin{rationale}
 Within the scope of a type definition, an instance of the type can be viewed as having that type or as having the implementation type.
 In the \lstinline$Time_of_day$ example, the difference is important.
+In the ©Time_of_day© example, the difference is important.
 Different languages have treated the distinction between the abstraction and the implementation in different ways.
 \begin{itemize}
 \item
 Inside a Clu cluster \cite{CLU}, the declaration of an instance states which view applies.
 Two primitives called \lstinline$up$ and \lstinline$down$ can be used to convert between the views.
+Two primitives called ©up© and ©down© can be used to convert between the views.
 \item
 The Simula class \cite{SIMULA87} is essentially a record type.
 Since the only operations on a record are member selection and assignment, which can not be overloaded, there is never any ambiguity as to whether the abstraction or the implementation view is being used.
 In {\CC}
 \cite{C++}, operations on class instances include assignment and ``\lstinline$&$'', which can be overloaded.
+\cite{C++}, operations on class instances include assignment and ``©&©'', which can be overloaded.
 A ``scope resolution'' operator can be used inside the class to specify whether the abstract or implementation version of the operation should be used.
 \item
 …
 In this case, explicit conversions between the derived type and the old type can be used.
 \end{itemize}
 \CFA's rules are like Clu's, except that implicit conversions and conversion costs allow it to do away with most uses of \lstinline$up$ and \lstinline$down$.
+\CFA's rules are like Clu's, except that implicit conversions and conversion costs allow it to do away with most uses of ©up© and ©down©.
 \end{rationale}
 …
 \subsubsection{Default functions and objects}
+A declaration\index{type declaration} of a type identifier \lstinline$T$ with type-class
+\lstinline$type$ implicitly declares a \define{default assignment} function
+\lstinline$T ?=?( T *, T )$\use{?=?}, with the same \Index{scope} and \Index{linkage} as the identifier \lstinline$T$.
+A declaration\index{type declaration} of a type identifier ©T© with type-class ©type© implicitly declares a \define{default assignment} function ©T ?=?( T *, T )©\use{?=?}, with the same \Index{scope} and \Index{linkage} as the identifier ©T©.
 \begin{rationale}
 Assignment is central to C's imperative programming style, and every existing C object type has assignment defined for it ( except for array types, which are treated as pointer types for purposes of assignment).
 Without this rule, nearly every inferred type parameter would need an accompanying assignment assertion parameter.
+If a type parameter should not have an assignment operation,
+\lstinline$dtype$ should be used.
+If a type parameter should not have an assignment operation, ©dtype© should be used.
 If a type should not have assignment defined, the user can define an assignment function that causes a run-time error, or provide an external declaration but no definition and thus cause a link-time error.
 \end{rationale}
+A definition\index{type definition} of a type identifier \lstinline$T$ with \Index{implementation type} \lstinline$I$ and type-class \lstinline$type$ implicitly defines a default assignment function.
+A definition\index{type definition} of a type identifier \lstinline$T$ with implementation type \lstinline$I$ and an assertion list implicitly defines \define{default function}s and
+\define{default object}s as declared by the assertion declarations.
+The default objects and functions have the same \Index{scope} and \Index{linkage} as the identifier \lstinline$T$.
+A definition\index{type definition} of a type identifier ©T© with \Index{implementation type} ©I© and type-class ©type© implicitly defines a default assignment function.
+A definition\index{type definition} of a type identifier ©T© with implementation type ©I© and an assertion list implicitly defines \define{default function}s and \define{default object}s as declared by the assertion declarations.
+The default objects and functions have the same \Index{scope} and \Index{linkage} as the identifier ©T©.
 Their values are determined as follows:
 \begin{itemize}
 \item
 If at the definition of \lstinline$T$ there is visible a declaration of an object with the same name as the default object, and if the type of that object with all occurrence of \lstinline$I$ replaced by \lstinline$T$ is compatible with the type of the default object, then the default object is initialized with that object.
 Otherwise the scope of the declaration of \lstinline$T$ must contain a definition of the default object.
+If at the definition of ©T© there is visible a declaration of an object with the same name as the default object, and if the type of that object with all occurrence of ©I© replaced by ©T© is compatible with the type of the default object, then the default object is initialized with that object.
+Otherwise the scope of the declaration of ©T© must contain a definition of the default object.
 \item
 If at the definition of \lstinline$T$ there is visible a declaration of a function with the same name as the default function, and if the type of that function with all occurrence of \lstinline$I$ replaced by \lstinline$T$ is compatible with the type of the default function, then the default function calls that function after converting its arguments and returns the converted result.
 Otherwise, if \lstinline$I$ contains exactly one anonymous member\index{anonymous member} such that at the definition of \lstinline$T$ there is visible a declaration of a function with the same name as the default function, and the type of that function with all occurrences of the anonymous member's type in its parameter list replaced by \lstinline$T$ is compatible with the type of the default function, then the default function calls that function after converting its arguments and returns the result.
 Otherwise the scope of the declaration of \lstinline$T$ must contain a definition of the default function.
+If at the definition of ©T© there is visible a declaration of a function with the same name as the default function, and if the type of that function with all occurrence of ©I© replaced by ©T© is compatible with the type of the default function, then the default function calls that function after converting its arguments and returns the converted result.
+Otherwise, if ©I© contains exactly one anonymous member\index{anonymous member} such that at the definition of ©T© there is visible a declaration of a function with the same name as the default function, and the type of that function with all occurrences of the anonymous member's type in its parameter list replaced by ©T© is compatible with the type of the default function, then the default function calls that function after converting its arguments and returns the result.
+Otherwise the scope of the declaration of ©T© must contain a definition of the default function.
 \end{itemize}
 \begin{rationale}
 …
 \end{rationale}
 A function or object with the same type and name as a default function or object that is declared within the scope of the definition of \lstinline$T$ replaces the default function or object.
+A function or object with the same type and name as a default function or object that is declared within the scope of the definition of ©T© replaces the default function or object.
 \examples
 …
 Pair b = { 1, 1 };
 \end{lstlisting}
+The definition of \lstinline$Pair$ implicitly defines two objects \lstinline$a$ and \lstinline$b$.
+\lstinline$Pair a$ inherits its value from the \lstinline$struct impl a$.
+The definition of
+\lstinline$Pair b$ is compulsory because there is no \lstinline$struct impl b$ to construct a value from.
+The definition of ©Pair© implicitly defines two objects ©a© and ©b©.
+©Pair a© inherits its value from the ©struct impl a©.
+The definition of ©Pair b© is compulsory because there is no ©struct impl b© to construct a value from.
 \begin{lstlisting}
 trait ss( otype T ) {
 …
         void munge( T * );
+}
 otype Whatsit | ss( Whatsit );@\use{Whatsit}@
 otype Doodad | ss( Doodad ) = struct doodad {@\use{Doodad}@
+otype Whatsit | ss( Whatsit );§\use{Whatsit}§
+otype Doodad | ss( Doodad ) = struct doodad {§\use{Doodad}§
         Whatsit; // anonymous member
         int extra;
 …
 Doodad clone( Doodad ) { ... }
 \end{lstlisting}
 The definition of \lstinline$Doodad$ implicitly defines three functions:
+The definition of ©Doodad© implicitly defines three functions:
 \begin{lstlisting}
 Doodad ?=?( Doodad *, Doodad );
 …
 void munge( Doodad * );
 \end{lstlisting}
+The assignment function inherits \lstinline$struct doodad$'s assignment function because the types match when \lstinline$struct doodad$ is replaced by \lstinline$Doodad$ throughout.
+\lstinline$munge()$ inherits \lstinline$Whatsit$'s \lstinline$munge()$ because the types match when
+\lstinline$Whatsit$ is replaced by \lstinline$Doodad$ in the parameter list. \lstinline$clone()$ does \emph{not} inherit \lstinline$Whatsit$'s \lstinline$clone()$: replacement in the parameter list yields ``\lstinline$Whatsit clone( Doodad )$'', which is not compatible with
+\lstinline$Doodad$'s \lstinline$clone()$'s type.
+Hence the definition of
+``\lstinline$Doodad clone( Doodad )$'' is necessary.
+The assignment function inherits ©struct doodad©'s assignment function because the types match when ©struct doodad©  is replaced by ©Doodad© throughout.
+©munge()© inherits ©Whatsit©'s ©munge()© because the types match when ©Whatsit© is replaced by ©Doodad© in the parameter list. ©clone()© does \emph{not} inherit ©Whatsit©'s ©clone()©: replacement in the parameter list yields ``©Whatsit clone( Doodad )©'', which is not compatible with ©Doodad©'s ©clone()©'s type.
+Hence the definition of ``©Doodad clone( Doodad )©'' is necessary.
 Default functions and objects are subject to the normal scope rules.
 \begin{lstlisting}
 otype T = @\ldots@;
 T a_T = @\ldots@;               // Default assignment used.
+otype T = ...;
+T a_T = ...;            // Default assignment used.
 T ?=?( T *, T );
 T a_T = @\ldots@;               // Programmer-defined assignment called.
+T a_T = ...;            // Programmer-defined assignment called.
 \end{lstlisting}
 \begin{rationale}
 …
 \begin{syntax}
 \oldlhs{labeled-statement}
 \rhs \lstinline$case$ \nonterm{case-value-list} : \nonterm{statement}
+\rhs ©case© \nonterm{case-value-list} : \nonterm{statement}
 \lhs{case-value-list}
 \rhs \nonterm{case-value}
 \rhs \nonterm{case-value-list} \lstinline$,$ \nonterm{case-value}
+\rhs \nonterm{case-value-list} ©,© \nonterm{case-value}
 \lhs{case-value}
 \rhs \nonterm{constant-expression}
 \rhs \nonterm{subrange}
 \lhs{subrange}
 \rhs \nonterm{constant-expression} \lstinline$~$ \nonterm{constant-expression}
+\rhs \nonterm{constant-expression} ©~© \nonterm{constant-expression}
 \end{syntax}
 …
 case 1~4, 9~14, 27~32:
 \end{lstlisting}
 The \lstinline$case$ and \lstinline$default$ clauses are restricted within the \lstinline$switch$ and \lstinline$choose$ statements, precluding Duff's device.
+The ©case© and ©default© clauses are restricted within the ©switch© and ©choose© statements, precluding Duff's device.
 \subsection{Expression and null statements}
 The expression in an expression statement is treated as being cast to \lstinline$void$.
+The expression in an expression statement is treated as being cast to ©void©.
 …
 \begin{syntax}
 \oldlhs{selection-statement}
 \rhs \lstinline$choose$ \lstinline$($ \nonterm{expression} \lstinline$)$ \nonterm{statement}
+\rhs ©choose© ©(© \nonterm{expression} ©)© \nonterm{statement}
 \end{syntax}
 The controlling expression \lstinline$E$ in the \lstinline$switch$ and \lstinline$choose$ statement:
+The controlling expression ©E© in the ©switch© and ©choose© statement:
 \begin{lstlisting}
 switch ( E ) ...
 …
 \end{lstlisting} may have more than one interpretation, but it shall have only one interpretation with an integral type.
 An \Index{integer promotion} is performed on the expression if necessary.
 The constant expressions in \lstinline$case$ statements with the switch are converted to the promoted type.
+The constant expressions in ©case© statements with the switch are converted to the promoted type.
 \setcounter{subsubsection}{3}
 \subsubsection{The \lstinline$choose$ statement}
 The \lstinline$choose$ statement is the same as the \lstinline$switch$ statement except control transfers to the end of the \lstinline$choose$ statement at a \lstinline$case$ or \lstinline$default$ labeled statement.
 The \lstinline$fallthru$ statement is used to fall through to the next \lstinline$case$ or \lstinline$default$ labeled statement.
+\subsubsection[The choose statement]{The \lstinline@choose@ statement}
+The ©choose© statement is the same as the ©switch© statement except control transfers to the end of the ©choose© statement at a ©case© or ©default© labeled statement.
+The ©fallthru© statement is used to fall through to the next ©case© or ©default© labeled statement.
 The following have identical meaning:
 \begin{flushleft}
 …
 \end{tabular}
 \end{flushleft}
 The \lstinline$choose$ statement addresses the problem of accidental fall-through associated with the \lstinline$switch$ statement.
+The ©choose© statement addresses the problem of accidental fall-through associated with the ©switch© statement.
 \subsection{Iteration statements}
 The controlling expression \lstinline$E$ in the loops
+The controlling expression ©E© in the loops
 \begin{lstlisting}
 if ( E ) ...
 while ( E ) ...
 do ... while ( E );
+\end{lstlisting} is treated as ``\lstinline$( int )((E)!=0)$''.
+\end{lstlisting}
+is treated as ``©( int )((E)!=0)©''.
 The statement
 \begin{lstlisting}
 for ( a; b; c ) @\ldots@
+for ( a; b; c ) ...
 \end{lstlisting} is treated as
 \begin{lstlisting}
 …
 \begin{syntax}
 \oldlhs{jump-statement}
 \rhs \lstinline$continue$ \nonterm{identifier}\opt
 \rhs \lstinline$break$ \nonterm{identifier}\opt
+\rhs ©continue© \nonterm{identifier}\opt
+\rhs ©break© \nonterm{identifier}\opt
 \rhs \ldots
 \rhs \lstinline$throw$ \nonterm{assignment-expression}\opt
 \rhs \lstinline$throwResume$ \nonterm{assignment-expression}\opt \nonterm{at-expression}\opt
 \lhs{at-expression} \lstinline$_At$ \nonterm{assignment-expression}
+\rhs ©throw© \nonterm{assignment-expression}\opt
+\rhs ©throwResume© \nonterm{assignment-expression}\opt \nonterm{at-expression}\opt
+\lhs{at-expression} ©_At© \nonterm{assignment-expression}
 \end{syntax}
 Labeled \lstinline$continue$ and \lstinline$break$ allow useful but restricted control-flow that reduces the need for the \lstinline$goto$ statement for exiting multiple nested control-structures.
+Labeled ©continue© and ©break© allow useful but restricted control-flow that reduces the need for the ©goto© statement for exiting multiple nested control-structures.
 \begin{lstlisting}
 L1: {                                                   // compound
 …
 \setcounter{subsubsection}{1}
 \subsubsection{The \lstinline$continue$ statement}
 The identifier in a \lstinline$continue$ statement shall name a label located on an enclosing iteration statement.
 \subsubsection{The \lstinline$break$ statement}
 The identifier in a \lstinline$break$ statement shall name a label located on an enclosing compound, selection or iteration statement.
 \subsubsection{The \lstinline$return$ statement}
 An expression in a \lstinline$return$ statement is treated as being cast to the result type of the function.
 \subsubsection{The \lstinline$throw$ statement}
+\subsubsection[The continue statement]{The \lstinline@continue@ statement}
+The identifier in a ©continue© statement shall name a label located on an enclosing iteration statement.
+\subsubsection[The break statement]{The \lstinline@break@ statement}
+The identifier in a ©break© statement shall name a label located on an enclosing compound, selection or iteration statement.
+\subsubsection[The return statement]{The \lstinline@return@ statement}
+An expression in a ©return© statement is treated as being cast to the result type of the function.
+\subsubsection[The throw statement]{The \lstinline@throw@ statement}
 When an exception is raised, \Index{propagation} directs control from a raise in the source execution to a handler in the faulting execution.
 \subsubsection{The \lstinline$throwResume$ statement}
+\subsubsection[The throwResume statement]{The \lstinline@throwResume@ statement}
 …
 \begin{syntax}
 \lhs{exception-statement}
 \rhs \lstinline$try$ \nonterm{compound-statement} \nonterm{handler-list}
 \rhs \lstinline$try$ \nonterm{compound-statement} \nonterm{finally-clause}
 \rhs \lstinline$try$ \nonterm{compound-statement} \nonterm{handler-list} \nonterm{finally-clause}
+\rhs ©try© \nonterm{compound-statement} \nonterm{handler-list}
+\rhs ©try© \nonterm{compound-statement} \nonterm{finally-clause}
+\rhs ©try© \nonterm{compound-statement} \nonterm{handler-list} \nonterm{finally-clause}
 \lhs{handler-list}
 \rhs \nonterm{handler-clause}
 \rhs \lstinline$catch$ \lstinline$($ \ldots \lstinline$)$ \nonterm{compound-statement}
 \rhs \nonterm{handler-clause} \lstinline$catch$ \lstinline$($ \ldots \lstinline$)$ \nonterm{compound-statement}
 \rhs \lstinline$catchResume$ \lstinline$($ \ldots \lstinline$)$ \nonterm{compound-statement}
 \rhs \nonterm{handler-clause} \lstinline$catchResume$ \lstinline$($ \ldots \lstinline$)$ \nonterm{compound-statement}
+\rhs ©catch© ©(© \ldots ©)© \nonterm{compound-statement}
+\rhs \nonterm{handler-clause} ©catch© ©(© \ldots ©)© \nonterm{compound-statement}
+\rhs ©catchResume© ©(© \ldots ©)© \nonterm{compound-statement}
+\rhs \nonterm{handler-clause} ©catchResume© ©(© \ldots ©)© \nonterm{compound-statement}
 \lhs{handler-clause}
 \rhs \lstinline$catch$ \lstinline$($ \nonterm{exception-declaration} \lstinline$)$ \nonterm{compound-statement}
 \rhs \nonterm{handler-clause} \lstinline$catch$ \lstinline$($ \nonterm{exception-declaration} \lstinline$)$ \nonterm{compound-statement}
 \rhs \lstinline$catchResume$ \lstinline$($ \nonterm{exception-declaration} \lstinline$)$ \nonterm{compound-statement}
 \rhs \nonterm{handler-clause} \lstinline$catchResume$ \lstinline$($ \nonterm{exception-declaration} \lstinline$)$ \nonterm{compound-statement}
+\rhs ©catch© ©(© \nonterm{exception-declaration} ©)© \nonterm{compound-statement}
+\rhs \nonterm{handler-clause} ©catch© ©(© \nonterm{exception-declaration} ©)© \nonterm{compound-statement}
+\rhs ©catchResume© ©(© \nonterm{exception-declaration} ©)© \nonterm{compound-statement}
+\rhs \nonterm{handler-clause} ©catchResume© ©(© \nonterm{exception-declaration} ©)© \nonterm{compound-statement}
 \lhs{finally-clause}
 \rhs \lstinline$finally$ \nonterm{compound-statement}
+\rhs ©finally© \nonterm{compound-statement}
 \lhs{exception-declaration}
 \rhs \nonterm{type-specifier}
 …
 \rhs \nonterm{new-abstract-declarator-tuple}
 \lhs{asynchronous-statement}
 \rhs \lstinline$enable$ \nonterm{identifier-list} \nonterm{compound-statement}
 \rhs \lstinline$disable$ \nonterm{identifier-list} \nonterm{compound-statement}
+\rhs ©enable© \nonterm{identifier-list} \nonterm{compound-statement}
+\rhs ©disable© \nonterm{identifier-list} \nonterm{compound-statement}
 \end{syntax}
 …
 \subsubsection{The \lstinline$try$ statement}
 The \lstinline$try$ statement is a block with associated handlers, called a \Index{guarded block};
+\subsubsection[The try statement]{The \lstinline@try@ statement}
+The ©try© statement is a block with associated handlers, called a \Index{guarded block};
 all other blocks are \Index{unguarded block}s.
 A \lstinline$goto$, \lstinline$break$, \lstinline$return$, or \lstinline$continue$ statement can be used to transfer control out of a try block or handler, but not into one.
 \subsubsection{The \lstinline$enable$/\lstinline$disable$ statements}
 The \lstinline$enable$/\lstinline$disable$ statements toggle delivery of \Index{asynchronous exception}s.
+A ©goto©, ©break©, ©return©, or ©continue© statement can be used to transfer control out of a try block or handler, but not into one.
+\subsubsection[The enable/disable statements]{The \lstinline@enable@/\lstinline@disable@ statements}
+The ©enable©/©disable© statements toggle delivery of \Index{asynchronous exception}s.
 …
 \subsection{Predefined macro names}
+The implementation shall define the macro names \lstinline$__LINE__$, \lstinline$__FILE__$,
+\lstinline$__DATE__$, and \lstinline$__TIME__$, as in the {\c11} standard.
+It shall not define the macro name \lstinline$__STDC__$.
+In addition, the implementation shall define the macro name \lstinline$__CFORALL__$ to be the decimal constant 1.
+The implementation shall define the macro names ©__LINE__©, ©__FILE__©, ©__DATE__©, and ©__TIME__©, as in the {\c11} standard.
+It shall not define the macro name ©__STDC__©.
+In addition, the implementation shall define the macro name ©__CFORALL__© to be the decimal constant 1.
 …
 The pointer, integral, and floating-point types are all \define{scalar types}.
 All of these types can be logically negated and compared.
 The assertion ``\lstinline$scalar( Complex )$'' should be read as ``type \lstinline$Complex$ is scalar''.
 \begin{lstlisting}
 trait scalar( otype T ) {@\impl{scalar}@
+The assertion ``©scalar( Complex )©'' should be read as ``type ©Complex© is scalar''.
+\begin{lstlisting}
+trait scalar( otype T ) {§\impl{scalar}§
         int !?( T );
         int ?<?( T, T ), ?<=?( T, T ), ?==?( T, T ), ?>=?( T, T ), ?>?( T, T ), ?!=?( T, T );
 …
 This is equivalent to inheritance of specifications.
 \begin{lstlisting}
 trait arithmetic( otype T | scalar( T ) ) {@\impl{arithmetic}@@\use{scalar}@
+trait arithmetic( otype T | scalar( T ) ) {§\impl{arithmetic}§§\use{scalar}§
         T +?( T ), -?( T );
         T ?*?( T, T ), ?/?( T, T ), ?+?( T, T ), ?-?( T, T );
 …
 \end{lstlisting}
+The various flavors of \lstinline$char$ and \lstinline$int$ and the enumerated types make up the
+\define{integral types}.
+\begin{lstlisting}
+trait integral( otype T | arithmetic( T ) ) {@\impl{integral}@@\use{arithmetic}@
+The various flavors of ©char© and ©int© and the enumerated types make up the \define{integral types}.
+\begin{lstlisting}
+trait integral( otype T | arithmetic( T ) ) {§\impl{integral}§§\use{arithmetic}§
         T ~?( T );
         T ?&?( T, T ), ?|?( T, T ), ?^?( T, T );
 …
 The only operation that can be applied to all modifiable lvalues is simple assignment.
 \begin{lstlisting}
 trait m_lvalue( otype T ) {@\impl{m_lvalue}@
+trait m_lvalue( otype T ) {§\impl{m_lvalue}§
         T ?=?( T *, T );
 };
 …
 Scalars can also be incremented and decremented.
 \begin{lstlisting}
 trait m_l_scalar( otype T | scalar( T ) | m_lvalue( T ) ) {@\impl{m_l_scalar}@
         T ?++( T * ), ?--( T * );@\use{scalar}@@\use{m_lvalue}@
+trait m_l_scalar( otype T | scalar( T ) | m_lvalue( T ) ) {§\impl{m_l_scalar}§
+        T ?++( T * ), ?--( T * );§\use{scalar}§§\use{m_lvalue}§
         T ++?( T * ), --?( T * );
 };
 …
 Modifiable arithmetic lvalues are both modifiable scalar lvalues and arithmetic.
 Note that this results in the ``inheritance'' of \lstinline$scalar$ along both paths.
 \begin{lstlisting}
 trait m_l_arithmetic( otype T | m_l_scalar( T ) | arithmetic( T ) ) {@\impl{m_l_arithmetic}@
         T ?/=?( T *, T ), ?*=?( T *, T );@\use{m_l_scalar}@@\use{arithmetic}@
+Note that this results in the ``inheritance'' of ©scalar© along both paths.
+\begin{lstlisting}
+trait m_l_arithmetic( otype T | m_l_scalar( T ) | arithmetic( T ) ) {§\impl{m_l_arithmetic}§
+        T ?/=?( T *, T ), ?*=?( T *, T );§\use{m_l_scalar}§§\use{arithmetic}§
         T ?+=?( T *, T ), ?-=?( T *, T );
 };
 trait m_l_integral( otype T | m_l_arithmetic( T ) | integral( T ) ) {@\impl{m_l_integral}@
         T ?&=?( T *, T ), ?|=?( T *, T ), ?^=?( T *, T );@\use{m_l_arithmetic}@
         T ?%=?( T *, T ), ?<<=?( T *, T ), ?>>=?( T *, T );@\use{integral}@
+trait m_l_integral( otype T | m_l_arithmetic( T ) | integral( T ) ) {§\impl{m_l_integral}§
+        T ?&=?( T *, T ), ?|=?( T *, T ), ?^=?( T *, T );§\use{m_l_arithmetic}§
+        T ?%=?( T *, T ), ?<<=?( T *, T ), ?>>=?( T *, T );§\use{integral}§
 };
 \end{lstlisting}
 …
 \subsection{Pointer and array types}
+Array types can barely be said to exist in {\c11}, since in most cases an array name is treated as a constant pointer to the first element of the array, and the subscript expression
+``\lstinline$a[i]$'' is equivalent to the dereferencing expression ``\lstinline$(*( a+( i )))$''.
+Technically, pointer arithmetic and pointer comparisons other than ``\lstinline$==$'' and
+``\lstinline$!=$'' are only defined for pointers to array elements, but the type system does not enforce those restrictions.
+Array types can barely be said to exist in {\c11}, since in most cases an array name is treated as a constant pointer to the first element of the array, and the subscript expression ``©a[i]©'' is equivalent to the dereferencing expression ``©(*( a+( i )))©''.
+Technically, pointer arithmetic and pointer comparisons other than ``©==©'' and ``©!=©'' are only defined for pointers to array elements, but the type system does not enforce those restrictions.
 Consequently, there is no need for a separate ``array type'' specification.
 Pointer types are scalar types.
+Like other scalar types, they have ``\lstinline$+$'' and
+``\lstinline$-$'' operators, but the types do not match the types of the operations in
+\lstinline$arithmetic$, so these operators cannot be consolidated in \lstinline$scalar$.
+\begin{lstlisting}
+trait pointer( type P | scalar( P ) ) {@\impl{pointer}@@\use{scalar}@
+Like other scalar types, they have ``©+©'' and ``©-©'' operators, but the types do not match the types of the operations in ©arithmetic©, so these operators cannot be consolidated in ©scalar©.
+\begin{lstlisting}
+trait pointer( type P | scalar( P ) ) {§\impl{pointer}§§\use{scalar}§
         P ?+?( P, long int ), ?+?( long int, P ), ?-?( P, long int );
         ptrdiff_t ?-?( P, P );
 };
 trait m_l_pointer( type P | pointer( P ) | m_l_scalar( P ) ) {@\impl{m_l_pointer}@
+trait m_l_pointer( type P | pointer( P ) | m_l_scalar( P ) ) {§\impl{m_l_pointer}§
         P ?+=?( P *, long int ), ?-=?( P *, long int );
         P ?=?( P *, void * );
 …
 Specifications that define the dereference operator ( or subscript operator ) require two parameters, one for the pointer type and one for the pointed-at ( or element ) type.
 Different specifications are needed for each set of \Index{type qualifier}s, because qualifiers are not included in types.
+The assertion ``\lstinline$|ptr_to( Safe_pointer, int )$'' should be read as
+``\lstinline$Safe_pointer$ acts like a pointer to \lstinline$int$''.
+\begin{lstlisting}
+trait ptr_to( otype P | pointer( P ), otype T ) {@\impl{ptr_to}@@\use{pointer}@
+The assertion ``©|ptr_to( Safe_pointer, int )©'' should be read as ``©Safe_pointer© acts like a pointer to ©int©''.
+\begin{lstlisting}
+trait ptr_to( otype P | pointer( P ), otype T ) {§\impl{ptr_to}§§\use{pointer}§
         lvalue T *?( P );
         lvalue T ?[?]( P, long int );
 };
 trait ptr_to_const( otype P | pointer( P ), otype T ) {@\impl{ptr_to_const}@
+trait ptr_to_const( otype P | pointer( P ), otype T ) {§\impl{ptr_to_const}§
         const lvalue T *?( P );
         const lvalue T ?[?]( P, long int );@\use{pointer}@
+        const lvalue T ?[?]( P, long int );§\use{pointer}§
 };
 trait ptr_to_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_volatile}@
+trait ptr_to_volatile( otype P | pointer( P ), otype T ) }§\impl{ptr_to_volatile}§
         volatile lvalue T *?( P );
         volatile lvalue T ?[?]( P, long int );@\use{pointer}@
+        volatile lvalue T ?[?]( P, long int );§\use{pointer}§
 };
 trait ptr_to_const_volatile( otype P | pointer( P ), otype T ) }@\impl{ptr_to_const_volatile}@
         const volatile lvalue T *?( P );@\use{pointer}@
+trait ptr_to_const_volatile( otype P | pointer( P ), otype T ) }§\impl{ptr_to_const_volatile}§
+        const volatile lvalue T *?( P );§\use{pointer}§
         const volatile lvalue T ?[?]( P, long int );
 };
 \end{lstlisting}
+Assignment to pointers is more complicated than is the case with other types, because the target's type can have extra type qualifiers in the pointed-at type: a ``\lstinline$T *$'' can be assigned to a ``\lstinline$const T *$'', a ``\lstinline$volatile T *$'', and a ``\lstinline$const volatile T *$''.
+Again, the pointed-at type is passed in, so that assertions can connect these specifications to the
+``\lstinline$ptr_to$'' specifications.
+\begin{lstlisting}
+trait m_l_ptr_to( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to}@ otype T | ptr_to( P, T )@\use{ptr_to}@ {
+Assignment to pointers is more complicated than is the case with other types, because the target's type can have extra type qualifiers in the pointed-at type: a ``©T *©'' can be assigned to a ``©const T *©'', a ``©volatile T *©'', and a ``©const volatile T *©''.
+Again, the pointed-at type is passed in, so that assertions can connect these specifications to the ``©ptr_to©'' specifications.
+\begin{lstlisting}
+trait m_l_ptr_to( otype P | m_l_pointer( P ),§\use{m_l_pointer}§§\impl{m_l_ptr_to}§ otype T | ptr_to( P, T )§\use{ptr_to}§ {
         P ?=?( P *, T * );
         T * ?=?( T **, P );
 };
 trait m_l_ptr_to_const( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_const}@ otype T | ptr_to_const( P, T )@\use{ptr_to_const}@) {
+trait m_l_ptr_to_const( otype P | m_l_pointer( P ),§\use{m_l_pointer}§§\impl{m_l_ptr_to_const}§ otype T | ptr_to_const( P, T )§\use{ptr_to_const}§) {
         P ?=?( P *, const T * );
         const T * ?=?( const T **, P );
 };
 trait m_l_ptr_to_volatile( otype P | m_l_pointer( P ),@\use{m_l_pointer}@@\impl{m_l_ptr_to_volatile}@ otype T | ptr_to_volatile( P, T )) {@\use{ptr_to_volatile}@
+trait m_l_ptr_to_volatile( otype P | m_l_pointer( P ),§\use{m_l_pointer}§§\impl{m_l_ptr_to_volatile}§ otype T | ptr_to_volatile( P, T )) {§\use{ptr_to_volatile}§
         P ?=?( P *, volatile T * );
         volatile T * ?=?( volatile T **, P );
 };
 trait m_l_ptr_to_const_volatile( otype P | ptr_to_const_volatile( P ),@\use{ptr_to_const_volatile}@@\impl{m_l_ptr_to_const_volatile}@
                 otype T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {@\use{m_l_ptr_to_const}@@\use{m_l_ptr_to_volatile}@
+trait m_l_ptr_to_const_volatile( otype P | ptr_to_const_volatile( P ),§\use{ptr_to_const_volatile}§§\impl{m_l_ptr_to_const_volatile}§
+                otype T | m_l_ptr_to_volatile( P, T ) | m_l_ptr_to_const( P )) {§\use{m_l_ptr_to_const}§§\use{m_l_ptr_to_volatile}§
         P ?=?( P *, const volatile T * );
         const volatile T * ?=?( const volatile T **, P );
 …
 An alternative specification can make use of the fact that qualification of the pointed-at type is part of a pointer type to capture that regularity.
 \begin{lstlisting}
 trait m_l_ptr_like( type MyP | m_l_pointer( MyP ),@\use{m_l_pointer}@@\impl{m_l_ptr_like}@ type CP | m_l_pointer( CP ) ) {
+trait m_l_ptr_like( type MyP | m_l_pointer( MyP ),§\use{m_l_pointer}§§\impl{m_l_ptr_like}§ type CP | m_l_pointer( CP ) ) {
         MyP ?=?( MyP *, CP );
         CP ?=?( CP *, MyP );
 };
 \end{lstlisting}
+The assertion ``\lstinline$| m_l_ptr_like( Safe_ptr, const int * )$'' should be read as
+``\lstinline$Safe_ptr$ is a pointer type like \lstinline$const int *$''.
+This specification has two defects, compared to the original four: there is no automatic assertion that dereferencing a
+\lstinline$MyP$ produces an lvalue of the type that \lstinline$CP$ points at, and the
+``\lstinline$|m_l_pointer( CP )$'' assertion provides only a weak assurance that the argument passed to \lstinline$CP$ really is a pointer type.
+The assertion ``©| m_l_ptr_like( Safe_ptr, const int * )©'' should be read as ``©Safe_ptr© is a pointer type like ©const int *©''.
+This specification has two defects, compared to the original four: there is no automatic assertion that dereferencing a ©MyP© produces an lvalue of the type that ©CP© points at, and the ``©|m_l_pointer( CP )©'' assertion provides only a weak assurance that the argument passed to ©CP© really is a pointer type.
 …
 Different operators often have related meanings;
+for instance, in C, ``\lstinline$+$'',
+``\lstinline$+=$'', and the two versions of ``\lstinline$++$'' perform variations of addition.
+for instance, in C, ``©+©'', ``©+=©'', and the two versions of ``©++©'' perform variations of addition.
 Languages like {\CC} and Ada allow programmers to define operators for new types, but do not require that these relationships be preserved, or even that all of the operators be implemented.
 Completeness and consistency is left to the good taste and discretion of the programmer.
 …
 The different comparison operators have obvious relationships, but there is no obvious subset of the operations to use in the implementation of the others.
 However, it is usually convenient to implement a single comparison function that returns a negative integer, 0, or a positive integer if its first argument is respectively less than, equal to, or greater than its second argument;
 the library function \lstinline$strcmp$ is an example.
 C and \CFA have an extra, non-obvious comparison operator: ``\lstinline$!$'', logical negation, returns 1 if its operand compares equal to 0, and 0 otherwise.
+the library function ©strcmp© is an example.
+C and \CFA have an extra, non-obvious comparison operator: ``©!©'', logical negation, returns 1 if its operand compares equal to 0, and 0 otherwise.
 \begin{lstlisting}
 trait comparable( otype T ) {
 …
 \end{lstlisting}
+Note that, although an arithmetic type would certainly provide comparison functions, and an integral type would provide arithmetic operations, there does not have to be any relationship among
+\lstinline$int_base$, \lstinline$arith_base$ and \lstinline$comparable$.
+Note that, although an arithmetic type would certainly provide comparison functions, and an integral type would provide arithmetic operations, there does not have to be any relationship among ©int_base©, ©arith_base© and ©comparable©.
 Note also that these declarations provide guidance and assistance, but they do not define an absolutely minimal set of requirements.
+A truly minimal implementation of an arithmetic type might only provide
+\lstinline$0$, \lstinline$1$, and \lstinline$?-=?$, which would be used by polymorphic
+\lstinline$?+=?$, \lstinline$?*=?$, and \lstinline$?/=?$ functions.
+Note also that \lstinline$short$ is an integer type in C11 terms, but has no operations!
+A truly minimal implementation of an arithmetic type might only provide ©0©, ©1©, and ©?-=?©, which would be used by polymorphic ©?+=?©, ©?*=?©, and ©?/=?© functions.
+Note also that ©short© is an integer type in C11 terms, but has no operations!
 …
 Restrict allowed to qualify anything, or type/dtype parameters, but only affects pointers.
 This gets into \lstinline$noalias$ territory.
 Qualifying anything (``\lstinline$short restrict rs$'') means pointer parameters of \lstinline$?++$, etc, would need restrict qualifiers.
+This gets into ©noalias© territory.
+Qualifying anything (``©short restrict rs©'') means pointer parameters of ©?++©, etc, would need restrict qualifiers.
 Enumerated types.
 …
 Color, enum Color ) really make sense? ?++ does, but it adds (int)1.
 Operators on {,signed,unsigned} char and other small types. ?<? harmless;
+Operators on {,signed,unsigned} char and other small types. ©?<?© harmless;
 ?*? questionable for chars.
 Generic selections make these choices visible.
+Safe conversion operators? Predefined
+``promotion'' function?
+\lstinline$register$ assignment might be handled as assignment to a temporary with copying back and forth, but copying must not be done by assignment.
+Don't use ptrdiff\_t by name in the predefineds.
+Safe conversion operators? Predefined ``promotion'' function?
+©register© assignment might be handled as assignment to a temporary with copying back and forth, but copying must not be done by assignment.
+Don't use ©ptrdiff_t© by name in the predefineds.
 Polymorphic objects.

doc/user/user.tex

-              rbb8ea30
+              rd668182
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Thu Apr 21 08:15:37 2016
 %% Update Count     : 131
+%% Last Modified On : Tue May  3 08:05:33 2016
+%% Update Count     : 246
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
+% inline code ©...© (copyright 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[openright,twoside]{article}
 …
 \CC~\cite{c++,ANSI14:C++} is an example of a similar project;
 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 \lstinline@int@ to \lstinline@char@ and enumerator from \lstinline@int@ to the type of its enumerators.}
+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 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.
 …
 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 type: \lstinline@abs@, \lstinline@labs@, \lstinline@llabs@, \lstinline@fabs@, \lstinline@fabsf@, \lstinline@fabsl@, \lstinline@cabsf@, \lstinline@cabs@, and \lstinline@cabsl@.
 Whereas, \CFA wraps each of these routines into one with the common name \lstinline@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 );
 …
 long double _Complex abs( long double _Complex );
 \end{lstlisting}
 The problem is the name clash between the library routine \lstinline@abs@ and the \CFA names \lstinline@abs@.
 Hence, names appearing in an \lstinline@extern "C"@ block have \newterm{C linkage}.
+The problem is the name clash between the library routine ©abs© and the \CFA names ©abs©.
+Hence, names appearing in an ©extern "C"© block have \newterm{C linkage}.
 Then overloading polymorphism uses a mechanism called \newterm{name mangling} to create unique names that are different from C names, which are not mangled.
 Hence, there is the same need as in \CC, to know if a name is a C or \CFA name, so it can be correctly formed.
 There is no way around this problem, other than C's approach of creating unique names for each pairing of operation and type.
 This example strongly illustrates a core idea in \CFA: \emph{the power of a name}.
 The name ``\lstinline@abs@'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
 Hence, knowing the name \lstinline@abs@ should be sufficient to apply it to any type where it is applicable.
+The name ``©abs©'' evokes the notion of absolute value, and many mathematical types provide the notion of absolute value.
+Hence, knowing the name ©abs© should be sufficient to apply it to any type where it is applicable.
 The time savings and safety of using one name uniformly versus $N$ unique names should not be underestimated.
+\section{Compiling \CFA Program}
+The command \lstinline@cfa@ is used to compile \CFA program(s).
+This command works like the GNU \lstinline@gcc@\index{gcc} command, e.g.:
+\begin{lstlisting}
+cfa [ gcc-options ] C/@{\CFA}@-files [ assembler/loader-files ]
+\end{lstlisting}
+\index{cfa@\lstinline$cfa$}\index{compilation!cfa@\lstinline$cfa$}
+By default, \CFA programs having the following \lstinline@gcc@ flags turned on:
+\section[Compiling CFA Program]{Compiling \CFA Program}
+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 ]
+\end{lstlisting}
+By default, \CFA programs having the following ©gcc© flags turned on:
 \begin{description}
+\item
+\hspace*{-4pt}\lstinline@-std=gnu99@
+\index{-std=gnu99@{\lstinline$-std=gnu99$}}\index{compilation option!-std=gnu99@{\lstinline$-std=gnu99$}}
+\item\hspace*{-4pt}\Indexc{-std=gnu99}\index{compilation option!-std=gnu99@{©-std=gnu99©}}
 The 1999 C standard plus GNU extensions.
+\item
+\hspace*{-4pt}\lstinline@-fgnu89-inline@
+\index{-fgnu89-inline@{\lstinline$-fgnu89-inline$}}\index{compilation option!-fgnu89-inline@{\lstinline$-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.
 \end{description}
 The following new \CFA option is available:
 \begin{description}
+\item
+\hspace*{-4pt}\lstinline@-CFA@
+\index{-CFA@{\lstinline$-CFA$}}\index{compilation option!-CFA@{\lstinline$-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}
 …
 The following preprocessor variables are available:
 \begin{description}
+\item
+\hspace*{-4pt}\lstinline$__CFA__$
+\index{__CFA__@{\lstinline$__CFA__$}}\index{preprocessor variables!__CFA__@{\lstinline$__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*{-4pt}\lstinline$__CFA_MINOR__$
+\index{__CFA_MINOR__@{\lstinline$__CFA_MINOR__$}}\index{preprocessor variables!__CFA_MINOR__@{\lstinline$__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*{-4pt}\lstinline$__CFA_PATCH__$
+\index{__CFA_PATCH__@%(__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*{-4pt}\lstinline$__CFORALL__$
+\index{__CFORALL__@%(__CFORALL__%)}\index{preprocessor variables!__CFORALL__@%(__CFORALL__%)}
+\item\hspace*{-4pt}\Indexc{__CFORALL__}\index{preprocessor variables!__CFORALL__@©__CFORALL__©}
 is always available during preprocessing and it has no value.
 \end{description}
 …
 \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}
 which conditionally includes the correct header file, if the program is compiled using \lstinline@gcc@ or \lstinline@cfa@.
+which conditionally includes the correct header file, if the program is compiled using ©gcc© or ©cfa©.
 …
 Numeric constants are extended to allow \Index{underscore}s within constants\index{constant!underscore}, e.g.:
 \begin{lstlisting}
 `_`147`_`483`_`648;                            // decimal constant
+®_®147®_®483®_®648;                            // decimal constant
 _ul;                                          // decimal unsigned long constant
 _377;                                          // octal constant
 …
 \begin{enumerate}
 \item
 A sequence of underscores is disallowed, e.g., \lstinline@12__34@ is invalid.
+A sequence of underscores is disallowed, e.g., ©12__34© is invalid.
 \item
 Underscores may only appear within a sequence of digits (regardless of the digit radix).
 In other words, an underscore cannot start or end a sequence of digits, e.g., \lstinline@_1@, \lstinline@1_@ and \lstinline@_1_@ are invalid (actually, the 1st and 3rd examples are identifier names).
+In other words, an underscore cannot start or end a sequence of digits, e.g., ©_1©, ©1_© and ©_1_© are invalid (actually, the 1st and 3rd examples are identifier names).
 \item
 A numeric prefix may end with an underscore;
 a numeric infix may begin and/or end with an underscore;
 a numeric suffix may begin with an underscore.
 For example, the octal \lstinline@0@ or hexadecimal \lstinline@0x@ prefix may end with an underscore \lstinline@0_377@ or \lstinline@0x_ff@;
 the exponent infix \lstinline@E@ may start or end with an underscore \lstinline@1.0_E10@, \lstinline@1.0E_10@ or \lstinline@1.0_E_10@;
 the type suffixes \lstinline@U@, \lstinline@L@, etc. may start with an underscore \lstinline@1_U@, \lstinline@1_ll@ or \lstinline@1.0E10_f@.
+For example, the octal ©0© or hexadecimal ©0x© prefix may end with an underscore ©0_377© or ©0x_ff©;
+the exponent infix ©E© may start or end with an underscore ©1.0_E10©, ©1.0E_10© or ©1.0_E_10©;
+the type suffixes ©U©, ©L©, etc. may start with an underscore ©1_U©, ©1_ll© or ©1.0E10_f©.
 \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).
 …
 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 \lstinline@*@ is used to indicate a pointer, square brackets \lstinline@[@\,\lstinline@]@ are used to represent an array, and parentheses \lstinline@()@ are used to indicate a routine parameter.
+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 \lstinline@x@ and \lstinline@y@ of type pointer to integer are defined in \CFA as follows:
+For instance, variables ©x© and ©y© of type pointer to integer are defined in \CFA as follows:
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
+`* int x, y;`
+®* int x, y;®
 \end{lstlisting}
+&
 …
 \end{quote2}
 All type qualifiers, i.e., \lstinline@const@ and \lstinline@volatile@, are used in the normal way with the new declarations but 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{30pt}}l@{\hspace{20pt}}l@{}}
 …
 \end{tabular}
 \end{quote2}
 All declaration qualifiers, i.e., \lstinline@extern@, \lstinline@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}
 …
 \end{quote2}
 Unsupported are K\&R C declarations where the base type defaults to \lstinline@int@, if no type is specified\footnote{
+Unsupported are K\&R C declarations where the base type defaults to ©int©, if no type is specified\footnote{
 At least one type specifier shall be given in the declaration specifiers in each declaration, and in the specifier-qualifier list in each structure declaration and type name~\cite[\S~6.7.2(2)]{C11}},
 e.g.:
 …
 \section{Type Operators}
 The new declaration syntax can be used in other contexts where types are required, e.g., casts and the pseudo-routine \lstinline@sizeof@:
+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{30pt}}l@{}}
 …
 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 ) {
         @\emph{routine body}@
+}
 \end{lstlisting}
 where routine \lstinline@f@ has three output (return values) and three input parameters.
+®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
+        §\emph{routine body}§
+}
+\end{lstlisting}
+where routine ©f© has three output (return values) and three input parameters.
 Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type specifications.
 In detail, the brackets, \lstinline@[]@, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
+In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
 Michael Tiemann, with help from Doug Lea, provided named return values in g++, circa 1989.}
 The value of each local return variable is automatically returned at routine termination.
 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
+[§\,§] g();                                             // no input or output parameters
 [ void ] g( void );                     // no input or output parameters
 \end{lstlisting}
 …
 int (*f(x))[ 5 ] int x; {}
 \end{lstlisting}
 The string ``\lstinline@int (*f(x))[ 5 ]@'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``\lstinline@[ 5 ] int x@'' declares a \CFA style parameter x of type array of 5 integers.
 Since the strings overlap starting with the open bracket, \lstinline@[@, there is an ambiguous interpretation for the string.
+The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter x of type array of 5 integers.
+Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
 \begin{lstlisting}
 …
 int f( int (* foo) );           // foo is redefined as a parameter name
 \end{lstlisting}
 The string ``\lstinline@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 \lstinline@*@ 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 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 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.
 …
 \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 \lstinline@return@ statement, as in:
+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() {
 …
+}
 \end{lstlisting}
 Because the value in the return variable is automatically returned when a \CFA routine terminates, the \lstinline@return@ statement \emph{does not} contain an expression, as in:
 \begin{lstlisting}
 `[ int x ]` f() {
+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:
+\begin{lstlisting}
+®[ int x ]® f() {
         ... x = 0; ... x = y; ...
         `return;` // implicitly return x
+}
 \end{lstlisting}
 When the return is encountered, the current value of \lstinline@x@ is returned to the calling routine.
 As well, ``falling off the end'' of a routine without a \lstinline@return@ statement is permitted, as in:
+        ®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 ] f() {
 …
 } // implicitly return x
 \end{lstlisting}
 In this case, the current value of \lstinline@x@ is returned to the calling routine just as if a \lstinline@return@ had been encountered.
+In this case, the current value of ©x© is returned to the calling routine just as if a ©return© had been encountered.
 …
 \subsection{Type Nesting}
 \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.
+\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{30pt}}l|l@{}}
 …
 int fred() {
         s.t.c = `S.`R;  // type qualification
         struct `S.`T t = { `S.`R, 1, 2 };
         enum `S.`C c;
         union `S.T.`U u;
+        s.t.c = ®S.®R;  // type qualification
+        struct ®S.®T t = { ®S.®R, 1, 2 };
+        enum ®S.®C c;
+        union ®S.T.®U u;
+}
 \end{lstlisting}
 \end{tabular}
 \end{quote2}
 In the left example in C, types \lstinline@C@, \lstinline@U@ and \lstinline@T@ are implicitly hoisted outside of type \lstinline@S@ into the containing block scope.
 In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``\lstinline@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``\lstinline@::@''.
+In the left example in C, types ©C©, ©U© and ©T© are implicitly hoisted outside of type ©S© into the containing block scope.
+In the right example in \CFA, the types are not hoisted and accessed using the field-selection operator ``©.©'' for type qualification, as does Java, rather than the \CC type-selection operator ``©::©''.
 …
 qsort( ia, size );              // sort ascending order using builtin ?<?
+{
         `int ?<?( int x, int y ) { return x > y; }` // nested routine
+        ®int ?<?( int x, int y ) { return x > y; }® // nested routine
         qsort( ia, size );      // sort descending order by local redefinition
+}
 …
 Nested routines are not first-class, meaning a nested routine cannot be returned if it has references to variables in its enclosing blocks;
 the only exception is references to the external block of the translation unit, as these variables persist for the duration of the program.
 The following program in undefined in \CFA (and \lstinline@gcc@\index{gcc})
+The following program in undefined in \CFA (and ©gcc©\index{gcc})
 \begin{lstlisting}
 [* [int]( int )] foo() {                // int (*foo())( int )
         int `i` = 7;
+        int ®i® = 7;
         int bar( int p ) {
                 `i` += 1;                                       // dependent on local variable
                 sout | `i` | endl;
+                ®i® += 1;                                       // dependent on local variable
+                sout | ®i® | endl;
+        }
         return bar;                                     // undefined because of local dependence
 …
 The general syntax of a tuple is:
 \begin{lstlisting}
 [ $\emph{exprlist}$ ]
 \end{lstlisting}
 where \lstinline@$\emph{exprlist}$@ is a list of one or more expressions separated by commas.
 The brackets, \lstinline$[]$, allow differentiating between tuples and expressions containing the C comma operator.
+[ §\emph{exprlist}§ ]
+\end{lstlisting}
+where ©$\emph{exprlist}$© is a list of one or more expressions separated by commas.
+The brackets, ©[]©, allow differentiating between tuples and expressions containing the C comma operator.
 The following are examples of tuples:
 \begin{lstlisting}
 …
 [ v+w, x*y, 3.14159, f() ]
 \end{lstlisting}
 Tuples are permitted to contain sub-tuples (i.e., nesting), such as \lstinline@[ [ 14, 21 ], 9 ]@, which is a 2-element tuple whose first element is itself a tuple.
+Tuples are permitted to contain sub-tuples (i.e., nesting), such as ©[ [ 14, 21 ], 9 ]©, which is a 2-element tuple whose first element is itself a tuple.
 Note, a tuple is not a record (structure);
 a record denotes a single value with substructure, whereas a tuple is multiple values with no substructure (see flattening coercion in Section 12.1).
 …
 The general syntax of a tuple type is:
 \begin{lstlisting}
 [ @\emph{typelist}@ ]
 \end{lstlisting}
 where \lstinline@$\emph{typelist}$@ is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
+[ §\emph{typelist}§ ]
+\end{lstlisting}
+where ©$\emph{typelist}$© is a list of one or more legal \CFA or C type specifications separated by commas, which may include other tuple type specifications.
 Examples of tuple types include:
 \begin{lstlisting}
 …
 [ * [ 5 ] int, * * char, * [ [ int, int ] ] (int, int) ]
 \end{lstlisting}
 Like tuples, tuple types may be nested, such as \lstinline@[ [ int, int ], int ]@, which is a 2-element tuple type whose first element is itself a tuple type.
+Like tuples, tuple types may be nested, such as ©[ [ int, int ], int ]©, which is a 2-element tuple type whose first element is itself a tuple type.
 Examples of declarations using tuple types are:
 …
 tuple does not have structure like a record; a tuple is simply converted into a list of components.
 \begin{rationale}
 The present implementation of \CFA does not support nested routine calls when the inner routine returns multiple values; i.e., a statement such as \lstinline@g( f() )@ is not supported.
+The present implementation of \CFA does not support nested routine calls when the inner routine returns multiple values; i.e., a statement such as ©g( f() )© is not supported.
 Using a temporary variable to store the  results of the inner routine and then passing this variable to the outer routine works, however.
 \end{rationale}
 …
 \begin{rationale}
 Unfortunately, C's syntax for subscripts precluded treating them as tuples.
 The C subscript list has the form \lstinline@[i][j]...@ and not \lstinline@i, j, ...]@.
 Therefore, there is no syntactic way for a routine returning multiple values to specify the different subscript values, e.g., \lstinline@f[g()]@ always means a single subscript value because there is only one set of brackets.
 Fixing this requires a major change to C because the syntactic form \lstinline@M[i, j, k]@ already has a particular meaning: \lstinline@i, j, k@ is a comma expression.
+The C subscript list has the form ©[i][j]...© and not ©[i, j, ...]©.
+Therefore, there is no syntactic way for a routine returning multiple values to specify the different subscript values, e.g., ©f[g()]© always means a single subscript value because there is only one set of brackets.
+Fixing this requires a major change to C because the syntactic form ©M[i, j, k]© already has a particular meaning: ©i, j, k© is a comma expression.
 \end{rationale}
 …
 [ a, b, c, d ] = w
 \end{lstlisting}
 \lstinline@w@ is implicitly opened to yield a tuple of four values, which are then assigned individually.
+©w© is implicitly opened to yield a tuple of four values, which are then assigned individually.
 A \newterm{flattening coercion} coerces a nested tuple, i.e., a tuple with one or more components, which are themselves tuples, into a flattened tuple, which is a tuple whose components are not tuples, as in:
 …
 First the right-hand tuple is flattened and then the values are assigned individually.
 Flattening is also performed on tuple types.
 For example, the type \lstinline@[ int, [ int, int ], int ]@ can be coerced, using flattening, into the type \lstinline@[ int, int, int, int ]@.
+For example, the type ©[ int, [ int, int ], int ]© can be coerced, using flattening, into the type ©[ int, int, int, int ]©.
 A \newterm{structuring coercion} is the opposite of flattening;
 a tuple is structured into a more complex nested tuple.
 For example, structuring the tuple \lstinline@[ 1, 2, 3, 4 ]@ into the tuple \lstinline@[ 1, [ 2, 3 ], 4 ]@ or the tuple type \lstinline@[ int, int, int, int ]@ into the tuple type \lstinline@[ int, [ int, int ], int ]@.
+For example, structuring the tuple ©[ 1, 2, 3, 4 ]© into the tuple ©[ 1, [ 2, 3 ], 4 ]© or the tuple type ©[ int, int, int, int ]© into the tuple type ©[ int, [ int, int ], int ]©.
 In the following example, the last assignment illustrates all the tuple coercions:
 \begin{lstlisting}
 …
 \end{lstlisting}
 Starting on the right-hand tuple in the last assignment statement, w is opened, producing a tuple of four values;
 therefore, the right-hand tuple is now the tuple \lstinline@[ [ 1, 2, 3, 4 ], 5 ]@.
 This tuple is then flattened, yielding \lstinline@[ 1, 2, 3, 4, 5 ]@, which is structured into \lstinline@[ 1, [ 2, 3, 4, 5 ] ]@ to match the tuple type of the left-hand side.
 The tuple \lstinline@[ 2, 3, 4, 5 ]@ is then closed to create a tuple value.
 Finally, \lstinline@x@ is assigned \lstinline@1@ and \lstinline@w@ is assigned the tuple value using multiple assignment (see Section 14).
+therefore, the right-hand tuple is now the tuple ©[ [ 1, 2, 3, 4 ], 5 ]©.
+This tuple is then flattened, yielding ©[ 1, 2, 3, 4, 5 ]©, which is structured into ©[ 1, [ 2, 3, 4, 5 ] ]© to match the tuple type of the left-hand side.
+The tuple ©[ 2, 3, 4, 5 ]© is then closed to create a tuple value.
+Finally, ©x© is assigned ©1© and ©w© is assigned the tuple value using multiple assignment (see Section 14).
 \begin{rationale}
 A possible additional language extension is to use the structuring coercion for tuples to initialize a complex record with a tuple.
 …
 Mass assignment has the following form:
 \begin{lstlisting}
 [ @\emph{lvalue}@, ..., @\emph{lvalue}@ ] = @\emph{expr}@;
 \end{lstlisting}
 The left-hand side is a tuple of \lstinline@$\emph{lvalues}$@, which is a list of expressions each yielding an address, i.e., any data object that can appear on the left-hand side of a conventional assignment statement.
 \lstinline@$\emph{expr}$@ is any standard arithmetic expression.
+[ §\emph{lvalue}§, ..., §\emph{lvalue}§ ] = §\emph{expr}§;
+\end{lstlisting}
+The left-hand side is a tuple of \emph{lvalues}, which is a list of expressions each yielding an address, i.e., any data object that can appear on the left-hand side of a conventional assignment statement.
+©$\emph{expr}$© is any standard arithmetic expression.
 Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
 …
 *a1 = t; *a2 = t; *a3 = t;
 \end{lstlisting}
 The temporary \lstinline@t@ is necessary to store the value of the expression to eliminate conversion issues.
+The temporary ©t© is necessary to store the value of the expression to eliminate conversion issues.
 The temporaries for the addresses are needed so that locations on the left-hand side do not change as the values are assigned.
 In this case, \lstinline@y[i]@ uses the previous value of \lstinline@i@ and not the new value set at the beginning of the mass assignment.
+In this case, ©y[i]© uses the previous value of ©i© and not the new value set at the beginning of the mass assignment.
 …
 Multiple assignment has the following form:
 \begin{lstlisting}
 [ @\emph{lvalue}@, . . ., @\emph{lvalue}@ ] = [ @\emph{expr}@, . . ., @\emph{expr}@ ];
 \end{lstlisting}
 The left-hand side is a tuple of \lstinline@$\emph{lvalues}$@, and the right-hand side is a tuple of \lstinline@$\emph{expr}$@s.
 Each \lstinline@$\emph{expr}$@ appearing on the righthand side of a multiple assignment statement is assigned to the corresponding \lstinline@$\emph{lvalues}$@ on the left-hand side of the statement using parallel semantics for each assignment.
+[ §\emph{lvalue}§, . . ., §\emph{lvalue}§ ] = [ §\emph{expr}§, . . ., §\emph{expr}§ ];
+\end{lstlisting}
+The left-hand side is a tuple of \emph{lvalues}, and the right-hand side is a tuple of \emph{expr}s.
+Each \emph{expr} appearing on the righthand side of a multiple assignment statement is assigned to the corresponding \emph{lvalues} on the left-hand side of the statement using parallel semantics for each assignment.
 An example of multiple assignment is:
 \begin{lstlisting}
 [ x, y, z ] = [ 1, 2, 3 ];
 \end{lstlisting}
 Here, the values \lstinline@1@, \lstinline@2@ and \lstinline@3@ are assigned, respectively, to the variables \lstinline@x@, \lstinline@y@ and \lstinline@z@.
+Here, the values ©1©, ©2© and ©3© are assigned, respectively, to the variables ©x©, ©y© and ©z©.
  A more complex example is:
 \begin{lstlisting}
 [ i, y[ i ], z ] = [ 1, i, a + b ];
 \end{lstlisting}
 Here, the values \lstinline@1@, \lstinline@i@ and \lstinline@a + b@ are assigned to the variables \lstinline@i@, \lstinline@y[i]@ and \lstinline@z@, respectively.
+Here, the values ©1©, ©i© and ©a + b© are assigned to the variables ©i©, ©y[i]© and ©z©, respectively.
  Note, the parallel semantics of
 multiple assignment ensures:
 …
 [ x, y ] = [ y, x ];
 \end{lstlisting}
 correctly interchanges (swaps) the values stored in \lstinline@x@ and \lstinline@y@.
+correctly interchanges (swaps) the values stored in ©x© and ©y©.
 The following cases are errors:
 \begin{lstlisting}
 …
 Cascade assignment has the following form:
 \begin{lstlisting}
 @\emph{tuple}@ = @\emph{tuple}@ = ... = @\emph{tuple}@;
+§\emph{tuple}§ = §\emph{tuple}§ = ... = §\emph{tuple}§;
 \end{lstlisting}
 and it has the same parallel semantics as for mass and multiple assignment.
 …
 Its general form is:
 \begin{lstlisting}
 @\emph{expr}@ . [ @\emph{fieldlist}@ ]
 @\emph{expr}@ -> [ @\emph{fieldlist}@ ]
 \end{lstlisting}
 \lstinline@$\emph{expr}$@ is any expression yielding a value of type record, e.g., \lstinline@struct@, \lstinline@union@.
 Each element of \lstinline@$\emph{ fieldlist}$@ is an element of the record specified by \lstinline@$\emph{expr}$@.
+§\emph{expr}§ . [ §\emph{fieldlist}§ ]
+§\emph{expr}§ -> [ §\emph{fieldlist}§ ]
+\end{lstlisting}
+\emph{expr} is any expression yielding a value of type record, e.g., ©struct©, ©union©.
+Each element of \emph{ fieldlist} is an element of the record specified by \emph{expr}.
 A record-field tuple may be used anywhere a tuple can be used. An example of the use of a record-field tuple is
 the following:
 …
 also, it is unnecessary to specify all the fields of a struct in a multiple record-field tuple.
 If a field of a \lstinline@struct@ is itself another \lstinline@struct@, multiple fields of this subrecord can be specified using a nested record-field tuple, as in the following example:
+If a field of a ©struct© is itself another ©struct©, multiple fields of this subrecord can be specified using a nested record-field tuple, as in the following example:
 \begin{lstlisting}
 struct inner {
 …
 \section{Labelled Break/Continue}
 While C provides \lstinline@break@ and \lstinline@continue@ statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
 Unfortunately, this restriction forces programmers to use \lstinline@goto@ to achieve the equivalent for more than one level of nesting.
 To prevent having to make this switch, the \lstinline@break@ and \lstinline@continue@ are extended with a target label to support static multi-level exit~\cite{Buhr85,Java}.
 For the labelled \lstinline@break@, it is possible to specify which control structure is the target for exit, as in:
+While C provides ©break© and ©continue© statements for altering control flow, both are restricted to one level of nesting for a particular control structure.
+Unfortunately, this restriction forces programmers to use ©goto© to achieve the equivalent for more than one level of nesting.
+To prevent having to make this switch, the ©break© and ©continue© are extended with a target label to support static multi-level exit~\cite{Buhr85,Java}.
+For the labelled ©break©, it is possible to specify which control structure is the target for exit, as in:
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 `L1:` for ( ... ) {
         `L2:` for ( ... ) {
                 `L3:` for ( ... ) {
                         ... break `L1`; ...
                         ... break `L2`; ...
                         ... break `L3`; // or break
+®L1:® for ( ... ) {
+        ®L2:® for ( ... ) {
+                ®L3:® for ( ... ) {
+                        ... break ®L1®; ...
+                        ... break ®L2®; ...
+                        ... break ®L3®; // or break
+                }
+        }
 …
 \end{quote2}
 The inner most loop has three exit points, which cause termination of one or more of the three nested loops, respectively.
 For the labelled \lstinline@continue@, it is possible to specify which control structure is the target for the next loop iteration, as in:
+For the labelled ©continue©, it is possible to specify which control structure is the target for the next loop iteration, as in:
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l@{}}
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CFA}}       & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{lstlisting}
 `L1`: for ( ... ) {
         `L2`: for ( ... ) {
                 `L3`: for ( ... ) {
                         ... continue `L1`; ...
                         ... continue `L2`; ...
                         ... continue `L3`; ...
+®L1®: for ( ... ) {
+        ®L2®: for ( ... ) {
+                ®L3®: for ( ... ) {
+                        ... continue ®L1®; ...
+                        ... continue ®L2®; ...
+                        ... continue ®L3®; ...
+                }
 …
 \end{quote2}
 The inner most loop has three restart points, which cause the next loop iteration to begin, respectively.
 For both \lstinline@break@ and \lstinline@continue@, the target label must be directly associated with a \lstinline@for@, \lstinline@while@ or \lstinline@do@ statement;
 for \lstinline@break@, the target label can also be associated with a \lstinline@switch@ statement.
 Both \lstinline@break@ and \lstinline@continue@ with target labels are simply a \lstinline@goto@ restricted in the following ways:
+For both ©break© and ©continue©, the target label must be directly associated with a ©for©, ©while© or ©do© statement;
+for ©break©, the target label can also be associated with a ©switch© statement.
+Both ©break© and ©continue© with target labels are simply a ©goto© restricted in the following ways:
 \begin{itemize}
 \item
 …
 Since they always transfers out of containing control structures, they cannot be used to branch into a control structure.
 \end{itemize}
 The advantage of the labelled \lstinline@break@/\lstinline@continue@ is that it allows static multi-level exits without having to use the \lstinline@goto@ statement and ties control flow to the target control structure rather than an arbitrary point in a program.
+The advantage of the labelled ©break©/©continue© is that it allows static multi-level exits without having to use the ©goto© statement and ties control flow to the target control structure rather than an arbitrary point in a program.
 Furthermore, the location of the label at the beginning of the target control structure informs the reader that complex control-flow is occurring in the body of the control structure.
 With \lstinline@goto@, the label at the end of the control structure fails to convey this important clue early enough to the reader.
+With ©goto©, the label at the end of the control structure fails to convey this important clue early enough to the reader.
 Finally, using an explicit target for the transfer instead of an implicit target allows new nested loop or switch constructs to be added or removed without affecting other constructs.
 The implicit targets of the current \lstinline@break@ and \lstinline@continue@, i.e., the closest enclosing loop or \lstinline@switch@, change as certain constructs are added or removed.
+The implicit targets of the current ©break© and ©continue©, i.e., the closest enclosing loop or ©switch©, change as certain constructs are added or removed.
 \section{Switch Statement}
 C allows a number of questionable forms for the \lstinline@switch@ statement:
+C allows a number of questionable forms for the ©switch© statement:
 \begin{enumerate}
 \item
 By default, the end of a \lstinline@case@ clause\footnote{
 In this section, the term \emph{case clause} refers to either a \lstinline@case@ or \lstinline@default@ clause.}
 \emph{falls through} to the next \lstinline@case@ clause in the \lstinline@switch@ statement;
 to exit a \lstinline@switch@ statement from a \lstinline@case@ clause requires explicitly terminating the clause with a transfer statement, most commonly \lstinline@break@, as in:
+By default, the end of a ©case© clause\footnote{
+In this section, the term \emph{case clause} refers to either a ©case© or ©default© clause.}
+\emph{falls through} to the next ©case© clause in the ©switch© statement;
+to exit a ©switch© statement from a ©case© clause requires explicitly terminating the clause with a transfer statement, most commonly ©break©, as in:
 \begin{lstlisting}
 switch ( i ) {
 …
 \end{lstlisting}
 In this example, case 2 is always done if case 3 is done.
 This control flow is difficult to simulate with if statements or a \lstinline@switch@ statement without fall-through as code must be duplicated or placed in a separate routine.
+This control flow is difficult to simulate with if statements or a ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
 C also uses fall-through to handle multiple case-values resulting in the same action, as in:
 \begin{lstlisting}
 …
 \end{lstlisting}
 However, this situation is handled in other languages without fall-through by allowing a list of case values.
 While fall-through itself is not a problem, the problem occurs when fall-through is the \lstinline@default@, as this semantics is not intuitive to most programmers and is different from virtually all other programming languages with a \lstinline@switch@ statement.
 Hence, \lstinline@default@ fall-through semantics results in a large number of programming errors as programmers often forget the \lstinline@break@ statement at the end of a \lstinline@case@ clause, resulting in inadvertent fall-through.
 \item
 It is possible to place \lstinline@case@ clauses on statements nested \emph{within} the body of the \lstinline@switch@ statement, as in:
+While fall-through itself is not a problem, the problem occurs when fall-through is the ©default©, as this semantics is not intuitive to most programmers and is different from virtually all other programming languages with a ©switch© statement.
+Hence, ©default© fall-through semantics results in a large number of programming errors as programmers often forget the ©break© statement at the end of a ©case© clause, resulting in inadvertent fall-through.
+\item
+It is possible to place ©case© clauses on statements nested \emph{within} the body of the ©switch© statement, as in:
 \begin{lstlisting}
 switch ( i ) {
 …
+}
 \end{lstlisting}
 which unrolls a loop N times (N = 8 above) and uses the \lstinline@switch@ statement to deal with any iterations not a multiple of N.
+which unrolls a loop N times (N = 8 above) and uses the ©switch© statement to deal with any iterations not a multiple of N.
 While efficient, this sort of special purpose usage is questionable:
 \begin{quote}
 …
 \end{quote}
 \item
 It is possible to place the \lstinline@default@ clause anywhere in the list of labelled clauses for a \lstinline@switch@ statement, rather than only at the end.
 Virtually all programming languages with a \lstinline@switch@ statement require the \lstinline@default@ clause to appear last in the case-clause list.
 The logic for this semantics is that after checking all the \lstinline@case@ clauses without success, the \lstinline@default@ clause is selected;
 hence, physically placing the \lstinline@default@ clause at the end of the \lstinline@case@ clause list matches with this semantics.
 This physical placement can be compared to the physical placement of an \lstinline@else@ clause at the end of a series of connected \lstinline@if@/\lstinline@else@ statements.
 \item
 It is possible to place unreachable code at the start of a \lstinline@switch@ statement, as in:
+It is possible to place the ©default© clause anywhere in the list of labelled clauses for a ©switch© statement, rather than only at the end.
+Virtually all programming languages with a ©switch© statement require the ©default© clause to appear last in the case-clause list.
+The logic for this semantics is that after checking all the ©case© clauses without success, the ©default© clause is selected;
+hence, physically placing the ©default© clause at the end of the ©case© clause list matches with this semantics.
+This physical placement can be compared to the physical placement of an ©else© clause at the end of a series of connected ©if©/©else© statements.
+\item
+It is possible to place unreachable code at the start of a ©switch© statement, as in:
 \begin{lstlisting}
 switch ( x ) {
 …
+}
 \end{lstlisting}
 While the declaration of the local variable \lstinline@y@ is useful and its scope is across all \lstinline@case@ clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
 Furthermore, any statements before the first \lstinline@case@ clause can only be executed if labelled and transfered to using a \lstinline@goto@, either from outside or inside of the \lstinline@switch@.
+While the declaration of the local variable ©y© is useful and its scope is across all ©case© clauses, the initialization for such a variable is defined to never be executed because control always transfers over it.
+Furthermore, any statements before the first ©case© clause can only be executed if labelled and transfered to using a ©goto©, either from outside or inside of the ©switch©.
 As mentioned, transfer into control structures should be forbidden.
 Transfers from within the \lstinline@switch@ body using a \lstinline@goto@ are equally unpalatable.
+Transfers from within the ©switch© body using a ©goto© are equally unpalatable.
 \end{enumerate}
 Before discussing potential language changes to deal with these problems, it is worth observing that in a typical C program:
 \begin{itemize}
 \item
 the number of \lstinline@switch@ statements is small,
 \item
 most \lstinline@switch@ statements are well formed (i.e., no Duff's device),
 \item
 the \lstinline@default@ clause is usually written as the last case-clause,
 \item
 and there is only a medium amount of fall-through from one \lstinline@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.
+the number of ©switch© statements is small,
+\item
+most ©switch© statements are well formed (i.e., no Duff's device),
+\item
+the ©default© clause is usually written as the last case-clause,
+\item
+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 should help to put the effects of suggested changes into perspective.
 …
 \begin{enumerate}
 \item
 Eliminating the \lstinline@default@ fall-through problem has the greatest potential for affecting existing code.
 However, even if fall-through is removed, most \lstinline@switch@ statements would continue to work because of the explicit transfers already present at the end of each \lstinline@case@ clause, and the common placement of the \lstinline@default@ clause at the end of the case list.
 In addition, the above grammar provides for the most common use of fall-through, i.e., a list of \lstinline@case@ clauses executing common code, e.g.:
+Eliminating the ©default© fall-through problem has the greatest potential for affecting existing code.
+However, even if fall-through is removed, most ©switch© statements would continue to work because of the explicit transfers already present at the end of each ©case© clause, and the common placement of the ©default© clause at the end of the case list.
+In addition, the above grammar provides for the most common use of fall-through, i.e., a list of ©case© clauses executing common code, e.g.:
 \begin{lstlisting}
 case 1:  case 2:  case 3: ...
 \end{lstlisting}
 Nevertheless, reversing the default action would have a non-trivial effect on case actions that compound, such as the above example of processing shell arguments.
 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of \lstinline@switch@ statement, called \lstinline@choose@, with no fall-through semantics.
 The \lstinline@choose@ statement is identical to the new \lstinline@switch@ statement, except there is no implicit fall-through between case-clauses and the \lstinline@break@ statement applies to the enclosing loop construct (as for the continue statement in a \lstinline@switch@ statement).
+Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no fall-through semantics.
+The ©choose© statement is identical to the new ©switch© statement, except there is no implicit fall-through between case-clauses and the ©break© statement applies to the enclosing loop construct (as for the continue statement in a ©switch© statement).
 It is still possible to fall-through if a case-clause ends with the new keyword fallthru, e.g.:
 \begin{lstlisting}
 …
 \item
 Eliminating Duff's device is straightforward and only invalidates a small amount of very questionable code.
 The solution is to allow \lstinline@case@ clauses to only appear at the same nesting level as the \lstinline@switch@ body, as is done in most other programming languages with \lstinline@switch@ statements.
 \item
 The issue of \lstinline@default@ at locations other than at the end of the cause clause can be solved by using good programming style, and there are a few reasonable situations involving fall-through where the \lstinline@default@ clause may appear is locations other than at the end.
+The solution is to allow ©case© clauses to only appear at the same nesting level as the ©switch© body, as is done in most other programming languages with ©switch© statements.
+\item
+The issue of ©default© at locations other than at the end of the cause clause can be solved by using good programming style, and there are a few reasonable situations involving fall-through where the ©default© clause may appear is locations other than at the end.
 Therefore, no language change is made for this issue.
 \item
 Dealing with unreachable code at the start of a \lstinline@switch@ statement is solved by defining the declaration-list, including any associated initialization, at the start of a \lstinline@switch@ statement body to be executed before the transfer to the appropriate \lstinline@case@ clause.
+Dealing with unreachable code at the start of a ©switch© statement is solved by defining the declaration-list, including any associated initialization, at the start of a ©switch© statement body to be executed before the transfer to the appropriate ©case© clause.
 This semantics is the same as for declarations at the start of a loop body, which are executed before each iteration of the loop body.
 As well, this grammar does not allow statements to appear before the first \lstinline@case@ clause.
+As well, this grammar does not allow statements to appear before the first ©case© clause.
 The change is compatible for declarations with initialization in this context because existing code cannot assume the initialization has occurred.
 The change is incompatible for statements, but any existing code using it is highly questionable, as in:
 …
+}
 \end{lstlisting}
 The statement after the \lstinline@switch@ can never be executed unless it is labelled.
 If it is labelled, it must be transfered to from outside or inside the \lstinline@switch@ statement, neither of which is acceptable control flow.
+The statement after the ©switch© can never be executed unless it is labelled.
+If it is labelled, it must be transfered to from outside or inside the ©switch© statement, neither of which is acceptable control flow.
 \end{enumerate}
 …
 \section{Case Clause}
 C restricts the \lstinline@case@ clause of a \lstinline@switch@ statement to a single value.
 For multiple \lstinline@case@ clauses associated with the same statement, it is necessary to have multiple \lstinline@case@ clauses rather than multiple values.
 Requiring a \lstinline@case@ clause for each value does not seem to be in the spirit of brevity normally associated with C.
 Therefore, the \lstinline@case@ clause is extended with a list of values, as in:
+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{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}l@{\hspace{20pt}}l@{}}
 …
 \begin{lstlisting}
 switch ( i ) {
   `case 1, 3, 5`:
+  ®case 1, 3, 5®:
         ...
   `case 2, 4, 6`:
+  ®case 2, 4, 6®:
         ...
+}
 …
 \begin{lstlisting}
 switch ( i ) {
   `case 1~5:`
+  ®case 1~5:®
         ...
   `case 10~15:`
+  ®case 10~15:®
         ...
+}
 …
 The syntax for using references in \CFA is the same as \CC with the exception of reference initialization.
 Use \lstinline@&@ to specify a reference, and access references just like regular objects, not like pointers (use dot notation to access fields).
+Use ©&© to specify a reference, and access references just like regular objects, not like pointers (use dot notation to access fields).
 When initializing a reference, \CFA uses a different syntax which differentiates reference initialization from assignment to a reference.
 The \lstinline@&@ is used on both sides of the expression to clarify that the address of the reference is being set to the address of the variable to which it refers.
+The ©&© is used on both sides of the expression to clarify that the address of the reference is being set to the address of the variable to which it refers.
 \begin{figure}
 …
 In \CFA, as in C, all scalar types can be incremented and
 decremented, which is defined in terms of adding or subtracting 1.
 The operations \lstinline@&&@, \lstinline@||@, and \lstinline@!@ can be applied to any scalar arguments and are defined in terms of comparison against 0 (ex. \lstinline@(a && b)@ becomes \lstinline@(a != 0 && b != 0)@).
+The operations ©&&©, ©||©, and ©!© can be applied to any scalar arguments and are defined in terms of comparison against 0 (ex. ©(a && b)© becomes ©(a != 0 && b != 0)©).
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any
 …
 polymorphic parameters, and user-defined pointer-like types may need a null value.
 Defining special
 constants for a user-defined type is more efficient than defining a conversion to the type from \lstinline@_Bool@.
+constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
 Why just 0 and 1? Why not other integers? No other integers have special status in C.
 …
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline@?[?]@ & subscripting \impl{?[?]}\\
 \lstinline@?()@ & function call \impl{?()}\\
 \lstinline@?++@ & postfix increment \impl{?++}\\
 \lstinline@?--@ & postfix decrement \impl{?--}\\
 \lstinline@++?@ & prefix increment \impl{++?}\\
 \lstinline@--?@ & prefix decrement \impl{--?}\\
 \lstinline@*?@ & dereference \impl{*?}\\
 \lstinline@+?@ & unary plus \impl{+?}\\
 \lstinline@-?@ & arithmetic negation \impl{-?}\\
 \lstinline@~?@ & bitwise negation \impl{~?}\\
 \lstinline@!?@ & logical complement \impl{"!?}\\
 \lstinline@?*?@ & multiplication \impl{?*?}\\
 \lstinline@?/?@ & division \impl{?/?}\\
+©?[?]© & subscripting \impl{?[?]}\\
+©?()© & function call \impl{?()}\\
+©?++© & postfix increment \impl{?++}\\
+©?--© & postfix decrement \impl{?--}\\
+©++?© & prefix increment \impl{++?}\\
+©--?© & prefix decrement \impl{--?}\\
+©*?© & dereference \impl{*?}\\
+©+?© & unary plus \impl{+?}\\
+©-?© & arithmetic negation \impl{-?}\\
+©~?© & bitwise negation \impl{~?}\\
+©!?© & logical complement \impl{"!?}\\
+©?*?© & multiplication \impl{?*?}\\
+©?/?© & division \impl{?/?}\\
 \end{tabular}\hfil
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline@?%?@ & remainder \impl{?%?}\\
 \lstinline@?+?@ & addition \impl{?+?}\\
 \lstinline@?-?@ & subtraction \impl{?-?}\\
 \lstinline@?<<?@ & left shift \impl{?<<?}\\
 \lstinline@?>>?@ & right shift \impl{?>>?}\\
 \lstinline@?<?@ & less than \impl{?<?}\\
 \lstinline@?<=?@ & less than or equal \impl{?<=?}\\
 \lstinline@?>=?@ & greater than or equal \impl{?>=?}\\
 \lstinline@?>?@ & greater than \impl{?>?}\\
 \lstinline@?==?@ & equality \impl{?==?}\\
 \lstinline@?!=?@ & inequality \impl{?"!=?}\\
 \lstinline@?&?@ & bitwise AND \impl{?&?}\\
+©?%?© & remainder \impl{?%?}\\
+©?+?© & addition \impl{?+?}\\
+©?-?© & subtraction \impl{?-?}\\
+©?<<?© & left shift \impl{?<<?}\\
+©?>>?© & right shift \impl{?>>?}\\
+©?<?© & less than \impl{?<?}\\
+©?<=?© & less than or equal \impl{?<=?}\\
+©?>=?© & greater than or equal \impl{?>=?}\\
+©?>?© & greater than \impl{?>?}\\
+©?==?© & equality \impl{?==?}\\
+©?!=?© & inequality \impl{?"!=?}\\
+©?&?© & bitwise AND \impl{?&?}\\
 \end{tabular}\hfil
 \begin{tabular}[t]{ll}
 %identifier & operation \\ \hline
 \lstinline@?^?@ & exclusive OR \impl{?^?}\\
 \lstinline@?|?@ & inclusive OR \impl{?"|?}\\
 \lstinline@?=?@ & simple assignment \impl{?=?}\\
 \lstinline@?*=?@ & multiplication assignment \impl{?*=?}\\
 \lstinline@?/=?@ & division assignment \impl{?/=?}\\
 \lstinline@?%=?@ & remainder assignment \impl{?%=?}\\
 \lstinline@?+=?@ & addition assignment \impl{?+=?}\\
 \lstinline@?-=?@ & subtraction assignment \impl{?-=?}\\
 \lstinline@?<<=?@ & left-shift assignment \impl{?<<=?}\\
 \lstinline@?>>=?@ & right-shift assignment \impl{?>>=?}\\
 \lstinline@?&=?@ & bitwise AND assignment \impl{?&=?}\\
 \lstinline@?^=?@ & exclusive OR assignment \impl{?^=?}\\
 \lstinline@?|=?@ & inclusive OR assignment \impl{?"|=?}\\
+©?^?© & exclusive OR \impl{?^?}\\
+©?|?© & inclusive OR \impl{?"|?}\\
+©?=?© & simple assignment \impl{?=?}\\
+©?*=?© & multiplication assignment \impl{?*=?}\\
+©?/=?© & division assignment \impl{?/=?}\\
+©?%=?© & remainder assignment \impl{?%=?}\\
+©?+=?© & addition assignment \impl{?+=?}\\
+©?-=?© & subtraction assignment \impl{?-=?}\\
+©?<<=?© & left-shift assignment \impl{?<<=?}\\
+©?>>=?© & right-shift assignment \impl{?>>=?}\\
+©?&=?© & bitwise AND assignment \impl{?&=?}\\
+©?^=?© & exclusive OR assignment \impl{?^=?}\\
+©?|=?© & inclusive OR assignment \impl{?"|=?}\\
 \end{tabular}
 \hfil
 …
 These identifiers are defined such that the question marks in the name identify the location of the operands.
 These operands represent the parameters to the functions, and define how the operands are mapped to the function call.
 For example, \lstinline@a + b@ becomes \lstinline@?+?(a, b)@.
+For example, ©a + b© becomes ©?+?(a, b)©.
 In the example below, a new type, myComplex, is defined with an overloaded constructor, + operator, and string operator.
 …
 \begin{quote2}
 \begin{tabular}{@{}l@{\hspace{30pt}}ll@{}}
 \multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{\lstinline@gcc@}\index{gcc} \\
+\multicolumn{1}{c@{\hspace{30pt}}}{\textbf{\CC}}        & \multicolumn{1}{c}{©gcc©}\index{gcc} \\
 \begin{lstlisting}
 …
 \end{itemize}
 In \CFA, \lstinline@typedef@ provides a mechanism to alias long type names with short ones, both globally and locally, but not eliminate the use of the short name.
 \lstinline@gcc@ provides \lstinline@typeof@ to declare a secondary variable from a primary variable.
+In \CFA, ©typedef© provides a mechanism to alias long type names with short ones, both globally and locally, but not eliminate the use of the short name.
+©gcc© provides ©typeof© to declare a secondary variable from a primary variable.
 \CFA also relies heavily on the specification of the left-hand side of assignment for type inferencing, so in many cases it is crucial to specify the type of the left-hand side to select the correct type of the right-hand expression.
 Only for overloaded routines with the same return type is variable type-inferencing possible.
 Finally, \lstinline@auto@ presents the programming problem of tracking down a type when the type is actually needed.
+Finally, ©auto© presents the programming problem of tracking down a type when the type is actually needed.
 For example, given
 \begin{lstlisting}
 auto j = `...`
 \end{lstlisting}
 and the need to write a routine to compute using \lstinline@j@
 \begin{lstlisting}
 void rtn( `...` parm );
+auto j = ®...®
+\end{lstlisting}
+and the need to write a routine to compute using ©j©
+\begin{lstlisting}
+void rtn( ®...® parm );
 rtn( j );
 \end{lstlisting}
 A programmer must work backwards to determine the type of \lstinline@j@'s initialization expression, reconstructing the possibly long generic type-name.
+A programmer must work backwards to determine the type of ©j©'s initialization expression, reconstructing the possibly long generic type-name.
 In this situation, having the type name or a short alias is very useful.
 …
 At some point, a programmer wants the type of the variable to remain constant and the expression to be in error when it changes.
 Given \lstinline@typedef@ and \lstinline@typeof@ in \CFA, and the strong need to use the type of left-hand side in inferencing, auto type-inferencing is not supported at this time.
+Given ©typedef© and ©typeof© in \CFA, and the strong need to use the type of left-hand side in inferencing, auto type-inferencing is not supported at this time.
 Should a significant need arise, this feature can be revisited.
 …
 } s;
 \end{lstlisting}
 The problem occurs in accesing these fields using the selection operation ``\lstinline@.@'':
+The problem occurs in accesing these fields using the selection operation ``©.©'':
 \begin{lstlisting}
 s.0 = 0;        // ambiguity with floating constant .0
 …
 To make this work, a space is required after the field selection:
 \begin{lstlisting}
 `s.@\textvisiblespace@0` = 0;
 `s.@\textvisiblespace@1` = 1;
+®s.§\textvisiblespace§0® = 0;
+®s.§\textvisiblespace§1® = 1;
 \end{lstlisting}
 While this sytact is awkward, it is unlikely many programers will name fields of a structure 0 or 1.
 Like the \CC lexical problem with closing template-syntax, e.g, \lstinline@Foo<Bar<int`>>`@, this issue can be solved with a more powerful lexer/parser.
 There are several ambiguous cases with operator identifiers, e.g., \lstinline@int *?*?()@, where the string \lstinline@*?*?@ can be lexed as \lstinline@*@/\lstinline@?*?@ or \lstinline@*?@/\lstinline@*?@.
 Since it is common practise to put a unary operator juxtaposed to an identifier, e.g., \lstinline@*i@, users will be annoyed if they cannot do this with respect to operator identifiers.
+Like the \CC lexical problem with closing template-syntax, e.g, ©Foo<Bar<int®>>®©, this issue can be solved with a more powerful lexer/parser.
+There are several ambiguous cases with operator identifiers, e.g., ©int *?*?()©, where the string ©*?*?© can be lexed as ©*©/©?*?© or ©*?©/©*?©.
+Since it is common practise to put a unary operator juxtaposed to an identifier, e.g., ©*i©, users will be annoyed if they cannot do this with respect to operator identifiers.
 Even with this special hack, there are 5 general cases that cannot be handled.
 The first case is for the function-call identifier \lstinline@?()@:
 \begin{lstlisting}
 int *@\textvisiblespace@?()();  // declaration: space required after '*'
 *@\textvisiblespace@?()();              // expression: space required after '*'
 \end{lstlisting}
 Without the space, the string \lstinline@*?()@ is ambiguous without N character look ahead;
 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument/parameter list.
+The first case is for the function-call identifier ©?()©:
+\begin{lstlisting}
+int *§\textvisiblespace§?()();  // declaration: space required after '*'
+*§\textvisiblespace§?()();              // expression: space required after '*'
+\end{lstlisting}
+Without the space, the string ©*?()© is ambiguous without N character look ahead;
+it requires scanning ahead to determine if there is a ©'('©, which is the start of an argument/parameter list.
 The 4 remaining cases occur in expressions:
 \begin{lstlisting}
 i++@\textvisiblespace@?i:0;             // space required before '?'
 i--@\textvisiblespace@?i:0;             // space required before '?'
 i@\textvisiblespace@?++i:0;             // space required after '?'
 i@\textvisiblespace@?--i:0;             // space required after '?'
 \end{lstlisting}
 In the first two cases, the string \lstinline@i++?@ is ambiguous, where this string can be lexed as \lstinline@i@ / \lstinline@++?@ or \lstinline@i++@ / \lstinline@?@;
 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
 In the second two cases, the string \lstinline@?++x@ is ambiguous, where this string can be lexed as \lstinline@?++@ / \lstinline@x@ or \lstinline@?@ / y\lstinline@++x@;
 it requires scanning ahead to determine if there is a \lstinline@'('@, which is the start of an argument list.
+i++§\textvisiblespace§?i:0;             // space required before '?'
+i--§\textvisiblespace§?i:0;             // space required before '?'
+i§\textvisiblespace§?++i:0;             // space required after '?'
+i§\textvisiblespace§?--i:0;             // space required after '?'
+\end{lstlisting}
+In the first two cases, the string ©i++?© is ambiguous, where this string can be lexed as ©i© / ©++?© or ©i++© / ©?©;
+it requires scanning ahead to determine if there is a ©'('©, which is the start of an argument list.
+In the second two cases, the string ©?++x© is ambiguous, where this string can be lexed as ©?++© / ©x© or ©?© / y©++x©;
+it requires scanning ahead to determine if there is a ©'('©, which is the start of an argument list.
 …
 \subsection{Comparing Key Features of \CFA}
+\subsection[Comparing Key Features of CFA]{Comparing Key Features of \CFA}
 …
 \begin{comment}
 \subsubsection{Modules/Packages}
+\subsubsection{Modules / Packages}
 \begin{lstlisting}
 …
 \subsubsection{\CC}
+\subsubsection[C++]{\CC}
 \CC is a general-purpose programming language.
 …
 \begin{enumerate}
 \item
 Change type of character literal \lstinline@int@ to \lstinline@char@.
+Change type of character literal ©int© to ©char©.
 This change allows overloading differentiation argument type matching, e.g.:
 \begin{lstlisting}
 …
 \item
 Change: String literals made \lstinline@const@ \\
 The type of a string literal is changed from \lstinline@array of char@ to \lstinline@array of const char@.
 The type of a wide string literal is changed from \lstinline@array of wchar_t@ to \lstinline@array of const wchar_t@. \\
+Change: String literals made ©const© \\
+The type of a string literal is changed from ©array of char© to ©array of const char©.
+The type of a wide string literal is changed from ©array of wchar_t© to ©array of const wchar_t©. \\
 Rationale: This avoids calling an inappropriate overloaded function, which might expect to be able to modify its argument.
 Effect on original feature: Change to semantics of well-defined feature. \\
 Difficulty of converting: Simple syntactic transformation, because string literals can be converted to \lstinline@char*;@ (4.2).
+Difficulty of converting: Simple syntactic transformation, because string literals can be converted to ©char*;© (4.2).
 The most common cases are handled by a new but deprecated standard conversion:
 \begin{lstlisting}
 …
 \CFA is C \emph{incompatible} on this issue, and provides semantics similar to \CC.
 Nested types are not hoisted and can be referenced using the field selection operator ``\lstinline@.@'', unlike the \CC scope-resolution operator ``\lstinline@::@''.
+Nested types are not hoisted and can be referenced using the field selection operator ``©.©'', unlike the \CC scope-resolution operator ``©::©''.
 Given that nested types in C are equivalent to not using them, i.e., they are essentially useless, it is unlikely there are any realistic usages that break because of this incompatibility.
 \item
 …
 struct Y yy; // valid C, invalid C++
 \end{lstlisting}
+Rationale: C++ classes have member functions which require that classes establish scopes. The C rule
+would leave classes as an incomplete scope mechanism which would prevent C++ programmers from maintaining
+locality within a class. A coherent set of scope rules for C++ based on the C rule would be very
+complicated and C++ programmers would be unable to predict reliably the meanings of nontrivial examples
+involving nested or local functions.
+Effect on original feature: Change of semantics of welldefined
+feature.
+Difficulty of converting: Semantic transformation. To make the struct type name visible in the scope of
+the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing
+struct is defined. Example:
+Rationale: C++ classes have member functions which require that classes establish scopes.
+The C rule would leave classes as an incomplete scope mechanism which would prevent C++ programmers from maintaining locality within a class. A coherent set of scope rules for C++ based on the C rule would be very complicated and C++ programmers would be unable to predict reliably the meanings of nontrivial examples involving nested or local functions.
+Effect on original feature: Change of semantics of welldefined feature.
+Difficulty of converting: Semantic transformation. To make the struct type name visible in the scope of the enclosing struct, the struct tag could be declared in the scope of the enclosing struct, before the enclosing struct is defined. Example:
 \begin{lstlisting}
 struct Y; // struct Y and struct X are at the same scope
 …
 };
 \end{lstlisting}
+All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of
+the enclosing struct could be exported to the scope of the enclosing struct. Note: this is a consequence of
+the difference in scope rules, which is documented in 3.3.
+All the definitions of C struct types enclosed in other struct definitions and accessed outside the scope of the enclosing struct could be exported to the scope of the enclosing struct.
+Note: this is a consequence of the difference in scope rules, which is documented in 3.3.
 How widely used: Seldom.
 \end{enumerate}
 …
 \begin{lstlisting}
 int x = 0, y = 1, z = 2;
 `sout` `|` x `|` y `|` z `| endl`;
+®sout® ®|® x ®|® y ®|® z ®| endl®;
 \end{lstlisting}
+&
 …
 \end{tabular}
 \end{quote2}
 The \CFA form is half as many characters, and is similar to Python I/O with respect to implicit separators.
+The \CFA form is half as many characters, and is similar to \Index{Python} I/O with respect to implicit separators.
 The logical-or operator is used because it is the lowest-priority overloadable operator, other than assignment.
 …
 A seperator does not appear at the start or end of a line.
 \begin{lstlisting}[belowskip=0pt]
 sout 1 | 2 | 3 | endl;
+sout | 1 | 2 | 3 | endl;
 \end{lstlisting}
 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 which is a local mechanism to disable insertion of the separator character.
 \item
 A seperator does not appear before a C string starting with the \Index{extended ASCII}\index{ASCII} characters: \lstinline[mathescape=off]@([{$£¥¿«@
+A seperator does not appear before a C string starting with the (extended) \Index{ASCII}\index{ASCII!extended} characters: \lstinline[mathescape=off]@([{$£¥¡¿«@
 %$
 \begin{lstlisting}[mathescape=off]
 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¿" | 7 | "x «" | 8 | endl;
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¡" | 7 | "x ¿" | 8 | "x «" | 9 | endl;
 \end{lstlisting}
 %$
 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
 x (1 x [2 x {3 x $4 x £5 x ¥6 x ¿7 x «8
+x (1 x [2 x {3 x $4 x £5 x ¥6 x ¡7 x ¿8 x «9
 \end{lstlisting}
 %$
 \item
 A seperator does not appear after a C string ending with the extended ASCII characters: \lstinline@,.:;!?)]}%¢»@
+A seperator does not appear after a C string ending with the (extended) \Index{ASCII}\index{ASCII!extended} characters: ©,.:;!?)]}%¢»©
 \begin{lstlisting}[belowskip=0pt]
 sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
          | 10 | "% x" | 11 | L"¢ x" | 12 | L"» x" | endl;
+         | 10 | "% x" | 11 | "¢ x" | 12 | "» x" | endl;
 \end{lstlisting}
 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
 …
 \end{lstlisting}
 \item
 A seperator does not appear before or after a C string begining/ending with the characters: \lstinline@\f\n\r\t\v\`'"@
+A seperator does not appear before or after a C string begining/ending with the \Index{ASCII} quote or whitespace characters: \lstinline[showspaces=true]@`'" \t\v\f\r\n@
 \begin{lstlisting}[belowskip=0pt]
+sout | "x '" | 1 | "' x \`" | 2 | "\` x \"" | 3 | "\" x" | endl;
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
+x '1' x \`2\` x "3" x
+\end{lstlisting}
+\begin{lstlisting}[showtabs=true,aboveskip=0pt]
+sout | "x\t" | 1 | "\tx" | endl;
+x       1       x
+sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x" | "x " | 4 | " x" | "x\t" | 1 | "\tx" | endl;
+\end{lstlisting}
+\begin{lstlisting}[mathescape=off,showspaces=true,showtabs=true,aboveskip=0pt,belowskip=0pt]
+x`1`x'2'x"3"x x 4 x x   1       x
 \end{lstlisting}
 \end{enumerate}
 …
 \end{lstlisting}
 \begin{lstlisting}[mathescape=off,showspaces=true,aboveskip=0pt,belowskip=0pt]
 2 3
+2 3
 \end{lstlisting}
 \begin{lstlisting}[mathescape=off,aboveskip=0pt,aboveskip=0pt,belowskip=0pt]
 …
 \end{lstlisting}
 %$
+\VRef[Figure]{f:ExampleIO} shows an example of input and output I/O in \CFA.
+\begin{figure}
+\begin{lstlisting}[mathescape=off]
+\begin{comment}
 #include <fstream>
 int main() {
+        char c;                                                                                                         // basic types
+        short int si;
+        unsigned short int usi;
+        int i;
+        unsigned int ui;
+        long int li;
+        unsigned long int uli;
+        long long int lli;
+        unsigned long long int ulli;
+        float f;
+        double d;
+        long double ld;
+        float _Complex fc;
+        double _Complex dc;
+        long double _Complex ldc;
+        char s1[10], s2[10];
+        ifstream in;                                                                                            // create / open file
+        open( &in, "input.data", "r" );
+        &in | &c                                                                                                        // character
+                | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli             // integral
+                | &f | &d | &ld                                                                                 // floating point
+                | &fc | &dc | &ldc                                                                              // floating-point complex
+                | cstr( s1 ) | cstr( s2, 10 );                                                  // C string, length unchecked and checked
+        sout | c | ' ' | endl                                                                           // character
+                 | si | usi | i | ui | li | uli | lli | ulli | endl             // integral
+                 | f | d | ld | endl                                                                    // floating point
+                 | fc | dc | ldc | endl;                                                                // complex
+        sout | endl;
+        sout | f | "" | d | "" | ld | endl                                                      // floating point without separator
+                 | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
+                 | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
+                 | s1 | "" | s2 | endl;                                                                 // C string withou separator
+        sout | endl;
+        sepSet( sout, ", $" );                                                                          // change separator, maximum of 15 characters
+        sout | f | d | ld | endl                                                                        // floating point without separator
+                 | fc | dc | ldc | endl                                                                 // complex without separator
+                 | s1 | s2 | endl;
+}
+$ cat input.data
+A 1 2 3 4 5 6 7 8 1.1 1.2 1.3 1.1+2.3 1.1-2.3 1.1-2.3 abc xyz
+$ a.out
+A
+2 3 4 5 6 7 8
+.1 1.2 1.3
+.1+2.3i 1.1-2.3i 1.1-2.3i
+.11.21.3
+.1+2.3i1.1-2.3i1.1-2.3i
+ abcxyz
+abcxyz
+.1, $1.2, $1.3
+.1+2.3i, $1.1-2.3i, $1.1-2.3i
+abc, $xyz
+\end{lstlisting}
+\caption{Example I/O}
+\label{f:ExampleIO}
+\end{figure}
+        int x = 3, y = 5, z = 7;
+        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+        sout | 1 | 2 | 3 | endl;
+        sout | '1' | '2' | '3' | endl;
+        sout | 1 | "" | 2 | "" | 3 | endl;
+        sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x $" | 4 | "x £" | 5 | "x ¥" | 6 | "x ¡" | 7 | "x ¿" | 8 | "x «" | 9 | endl;
+        sout | 1 | ", x" | 2 | ". x" | 3 | ": x" | 4 | "; x" | 5 | "! x" | 6 | "? x" | 7 | ") x" | 8 | "] x" | 9 | "} x"
+                 | 10 | "% x" | 11 | "¢ x" | 12 | "» x" | endl;
+        sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x" | "x " | 4 | " x" | "x\t" | 1 | "\tx" | endl;
+        sout | sepOn | 1 | 2 | 3 | sepOn | endl;        // separator at start of line
+        sout | 1 | sepOff | 2 | 3 | endl;                       // turn off implicit separator temporarily
+        sout | sepDisable | 1 | 2 | 3 | endl;           // turn off implicit separation, affects all subsequent prints
+        sout | 1 | sepOn | 2 | 3 | endl;                        // turn on implicit separator temporarily
+        sout | sepEnable | 1 | 2 | 3 | endl;            // turn on implicit separation, affects all subsequent prints
+        sepSet( sout, ", $" );                                          // change separator from " " to ", $"
+        sout | 1 | 2 | 3 | endl;
+}
+// Local Variables: //
+// tab-width: 4 //
+// End: //
+\end{comment}
+%$
 …
 \begin{lstlisting}
 forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( void );§\indexc{malloc}§
 forall( otype T ) T * malloc( char fill );
 forall( otype T ) T * malloc( T * ptr, size_t size );
 forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
 forall( otype T ) T * calloc( size_t size );
 forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * calloc( size_t nmemb );§\indexc{calloc}§
+forall( otype T ) T * realloc( T * ptr, size_t size );§\indexc{ato}§
 forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
 forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * aligned_alloc( size_t alignment );§\indexc{ato}§
 forall( otype T ) T * memalign( size_t alignment );             // deprecated
 forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
 …
 \subsection{ato/strto}
 \begin{lstlisting}
 int ato( const char * ptr );
+\subsection{ato / strto}
+\begin{lstlisting}
+int ato( const char * ptr );§\indexc{ato}§
 unsigned int ato( const char * ptr );
 long int ato( const char * ptr );
 …
 \subsection{bsearch/qsort}
+\subsection{bsearch / qsort}
 \begin{lstlisting}
 forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension );
+T * bsearch( const T key, const T * arr, size_t dimension );§\indexc{bsearch}§
 forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
+void qsort( const T * arr, size_t dimension );§\indexc{qsort}§
 \end{lstlisting}
 …
 \begin{lstlisting}
+char abs( char );
+extern "C" {
+int abs( int );                         // use default C routine for int
+} // extern "C"
+char abs( char );§\indexc{abs}§
+int abs( int );
 long int abs( long int );
 long long int abs( long long int );
 …
 double abs( double );
 long double abs( long double );
+float _Complex abs( float _Complex );
+double _Complex abs( double _Complex );
+long double _Complex abs( long double _Complex );
+\end{lstlisting}
+\subsection{floor/ceil}
+\begin{lstlisting}
+float floor( float );
+extern "C" {
+double floor( double );         // use C routine for double
+} // extern "C"
+long double floor( long double );
+float ceil( float );
+extern "C" {
+double ceil( double );          // use C routine for double
+} // extern "C"
+long double ceil( long double );
+float abs( float _Complex );
+double abs( double _Complex );
+long double abs( long double _Complex );
 \end{lstlisting}
 …
 \begin{lstlisting}
 void rand48seed( long int s );
 char rand48();
+void rand48seed( long int s );§\indexc{rand48seed}§
+char rand48();§\indexc{rand48}§
 int rand48();
 unsigned int rand48();
 …
 \subsection{min/max/swap}
+\subsection{min / max / swap}
 \begin{lstlisting}
 forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 );
+T min( const T t1, const T t2 );§\indexc{min}§
 forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 );
+T max( const T t1, const T t2 );§\indexc{max}§
 forall( otype T )
+void swap( T * t1, T * t2 );
+void swap( T * t1, T * t2 );§\indexc{swap}§
+\end{lstlisting}
+\section{Math Library}
+\label{s:Math Library}
+The goal of the \CFA math-library is to wrap many of the existing C math library-routines that are explicitly polymorphic into implicitly polymorphic versions.
+\subsection{General}
+\begin{lstlisting}
+float fabs( float );§\indexc{fabs}§
+double fabs( double );
+long double fabs( long double );
+float cabs( float _Complex );
+double cabs( double _Complex );
+long double cabs( long double _Complex );
+float ?%?( float, float );§\indexc{fmod}§
+float fmod( float, float );
+double ?%?( double, double );
+double fmod( double, double );
+long double ?%?( long double, long double );
+long double fmod( long double, long double );
+float remainder( float, float );§\indexc{remainder}§
+double remainder( double, double );
+long double remainder( long double, long double );
+[ int, float ] remquo( float, float );§\indexc{remquo}§
+float remquo( float, float, int * );
+[ int, double ] remquo( double, double );
+double remquo( double, double, int * );
+[ int, long double ] remquo( long double, long double );
+long double remquo( long double, long double, int * );
+[ int, float ] div( float, float );                                             // alternative name for remquo
+float div( float, float, int * );§\indexc{div}§
+[ int, double ] div( double, double );
+double div( double, double, int * );
+[ int, long double ] div( long double, long double );
+long double div( long double, long double, int * );
+float fma( float, float, float );§\indexc{fma}§
+double fma( double, double, double );
+long double fma( long double, long double, long double );
+float fdim( float, float );§\indexc{fdim}§
+double fdim( double, double );
+long double fdim( long double, long double );
+float nan( const char * );§\indexc{nan}§
+double nan( const char * );
+long double nan( const char * );
+\end{lstlisting}
+\subsection{Exponential}
+\begin{lstlisting}
+float exp( float );§\indexc{exp}§
+double exp( double );
+long double exp( long double );
+float _Complex exp( float _Complex );
+double _Complex exp( double _Complex );
+long double _Complex exp( long double _Complex );
+float exp2( float );§\indexc{exp2}§
+double exp2( double );
+long double exp2( long double );
+float _Complex exp2( float _Complex );
+double _Complex exp2( double _Complex );
+long double _Complex exp2( long double _Complex );
+float expm1( float );§\indexc{expm1}§
+double expm1( double );
+long double expm1( long double );
+float log( float );§\indexc{log}§
+double log( double );
+long double log( long double );
+float _Complex log( float _Complex );
+double _Complex log( double _Complex );
+long double _Complex log( long double _Complex );
+float log2( float );§\indexc{log2}§
+double log2( double );
+long double log2( long double );
+float _Complex log2( float _Complex );
+double _Complex log2( double _Complex );
+long double _Complex log2( long double _Complex );
+float log10( float );§\indexc{log10}§
+double log10( double );
+long double log10( long double );
+float _Complex log10( float _Complex );
+double _Complex log10( double _Complex );
+long double _Complex log10( long double _Complex );
+float log1p( float );§\indexc{log1p}§
+double log1p( double );
+long double log1p( long double );
+int ilogb( float );§\indexc{ilogb}§
+int ilogb( double );
+int ilogb( long double );
+float logb( float );§\indexc{logb}§
+double logb( double );
+long double logb( long double );
+\end{lstlisting}
+\subsection{Power}
+\begin{lstlisting}
+float sqrt( float );§\indexc{sqrt}§
+double sqrt( double );
+long double sqrt( long double );
+float _Complex sqrt( float _Complex );
+double _Complex sqrt( double _Complex );
+long double _Complex sqrt( long double _Complex );
+float cbrt( float );§\indexc{cbrt}§
+double cbrt( double );
+long double cbrt( long double );
+float hypot( float, float );§\indexc{hypot}§
+double hypot( double, double );
+long double hypot( long double, long double );
+float pow( float, float );§\indexc{pow}§
+double pow( double, double );
+long double pow( long double, long double );
+float _Complex pow( float _Complex, float _Complex );
+double _Complex pow( double _Complex, double _Complex );
+long double _Complex pow( long double _Complex, long double _Complex );
+\end{lstlisting}
+\subsection{Trigonometric}
+\begin{lstlisting}
+float sin( float );§\indexc{sin}§
+double sin( double );
+long double sin( long double );
+float _Complex sin( float _Complex );
+double _Complex sin( double _Complex );
+long double _Complex sin( long double _Complex );
+float cos( float );§\indexc{cos}§
+double cos( double );
+long double cos( long double );
+float _Complex cos( float _Complex );
+double _Complex cos( double _Complex );
+long double _Complex cos( long double _Complex );
+float tan( float );§\indexc{tan}§
+double tan( double );
+long double tan( long double );
+float _Complex tan( float _Complex );
+double _Complex tan( double _Complex );
+long double _Complex tan( long double _Complex );
+float asin( float );§\indexc{asin}§
+double asin( double );
+long double asin( long double );
+float _Complex asin( float _Complex );
+double _Complex asin( double _Complex );
+long double _Complex asin( long double _Complex );
+float acos( float );§\indexc{acos}§
+double acos( double );
+long double acos( long double );
+float _Complex acos( float _Complex );
+double _Complex acos( double _Complex );
+long double _Complex acos( long double _Complex );
+float atan( float );§\indexc{atan}§
+double atan( double );
+long double atan( long double );
+float _Complex atan( float _Complex );
+double _Complex atan( double _Complex );
+long double _Complex atan( long double _Complex );
+float atan2( float, float );§\indexc{atan2}§
+double atan2( double, double );
+long double atan2( long double, long double );
+float atan( float, float );                                                             // alternative name for atan2
+double atan( double, double );§\indexc{atan}§
+long double atan( long double, long double );
+\end{lstlisting}
+\subsection{Hyperbolic}
+\begin{lstlisting}
+float sinh( float );§\indexc{sinh}§
+double sinh( double );
+long double sinh( long double );
+float _Complex sinh( float _Complex );
+double _Complex sinh( double _Complex );
+long double _Complex sinh( long double _Complex );
+float cosh( float );§\indexc{cosh}§
+double cosh( double );
+long double cosh( long double );
+float _Complex cosh( float _Complex );
+double _Complex cosh( double _Complex );
+long double _Complex cosh( long double _Complex );
+float tanh( float );§\indexc{tanh}§
+double tanh( double );
+long double tanh( long double );
+float _Complex tanh( float _Complex );
+double _Complex tanh( double _Complex );
+long double _Complex tanh( long double _Complex );
+float asinh( float );§\indexc{asinh}§
+double asinh( double );
+long double asinh( long double );
+float _Complex asinh( float _Complex );
+double _Complex asinh( double _Complex );
+long double _Complex asinh( long double _Complex );
+float acosh( float );§\indexc{acosh}§
+double acosh( double );
+long double acosh( long double );
+float _Complex acosh( float _Complex );
+double _Complex acosh( double _Complex );
+long double _Complex acosh( long double _Complex );
+float atanh( float );§\indexc{atanh}§
+double atanh( double );
+long double atanh( long double );
+float _Complex atanh( float _Complex );
+double _Complex atanh( double _Complex );
+long double _Complex atanh( long double _Complex );
+\end{lstlisting}
+\subsection{Error / Gamma}
+\begin{lstlisting}
+float erf( float );§\indexc{erf}§
+double erf( double );
+long double erf( long double );
+float _Complex erf( float _Complex );
+double _Complex erf( double _Complex );
+long double _Complex erf( long double _Complex );
+float erfc( float );§\indexc{erfc}§
+double erfc( double );
+long double erfc( long double );
+float _Complex erfc( float _Complex );
+double _Complex erfc( double _Complex );
+long double _Complex erfc( long double _Complex );
+float lgamma( float );§\indexc{lgamma}§
+double lgamma( double );
+long double lgamma( long double );
+float lgamma( float, int * );
+double lgamma( double, int * );
+long double lgamma( long double, int * );
+float tgamma( float );§\indexc{tgamma}§
+double tgamma( double );
+long double tgamma( long double );
+\end{lstlisting}
+\subsection{Nearest Integer}
+\begin{lstlisting}
+float floor( float );§\indexc{floor}§
+double floor( double );
+long double floor( long double );
+float ceil( float );§\indexc{ceil}§
+double ceil( double );
+long double ceil( long double );
+float trunc( float );§\indexc{trunc}§
+double trunc( double );
+long double trunc( long double );
+float rint( float );§\indexc{rint}§
+long double rint( long double );
+long int rint( float );
+long int rint( double );
+long int rint( long double );
+long long int rint( float );
+long long int rint( double );
+long long int rint( long double );
+long int lrint( float );§\indexc{lrint}§
+long int lrint( double );
+long int lrint( long double );
+long long int llrint( float );
+long long int llrint( double );
+long long int llrint( long double );
+float nearbyint( float );§\indexc{nearbyint}§
+double nearbyint( double );
+long double nearbyint( long double );
+float round( float );§\indexc{round}§
+long double round( long double );
+long int round( float );
+long int round( double );
+long int round( long double );
+long long int round( float );
+long long int round( double );
+long long int round( long double );
+long int lround( float );§\indexc{lround}§
+long int lround( double );
+long int lround( long double );
+long long int llround( float );
+long long int llround( double );
+long long int llround( long double );
+\end{lstlisting}
+\subsection{Manipulation}
+\begin{lstlisting}
+float copysign( float, float );§\indexc{copysign}§
+double copysign( double, double );
+long double copysign( long double, long double );
+float frexp( float, int * );§\indexc{frexp}§
+double frexp( double, int * );
+long double frexp( long double, int * );
+float ldexp( float, int );§\indexc{ldexp}§
+double ldexp( double, int );
+long double ldexp( long double, int );
+[ float, float ] modf( float );§\indexc{modf}§
+float modf( float, float * );
+[ double, double ] modf( double );
+double modf( double, double * );
+[ long double, long double ] modf( long double );
+long double modf( long double, long double * );
+float nextafter( float, float );§\indexc{nextafter}§
+double nextafter( double, double );
+long double nextafter( long double, long double );
+float nexttoward( float, long double );§\indexc{nexttoward}§
+double nexttoward( double, long double );
+long double nexttoward( long double, long double );
+float scalbn( float, int );§\indexc{scalbn}§
+double scalbn( double, int );
+long double scalbn( long double, int );
+float scalbln( float, long int );§\indexc{scalbln}§
+double scalbln( double, long int );
+long double scalbln( long double, long int );
 \end{lstlisting}
 …
 \begin{lstlisting}
 // implementation
 struct Rational {
+struct Rational {§\indexc{Rational}§
         long int numerator, denominator;                                        // invariant: denominator > 0
 }; // Rational

src/CodeGen/CodeGenerator.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // CodeGenerator.cc --
+// CodeGenerator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:32:16 2016
 // Update Count     : 243
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 06 16:01:00 2016
+// Update Count     : 255
 //
 …
         string mangleName( DeclarationWithType *decl ) {
                 if ( decl->get_mangleName() != "" ) {
+                        return decl->get_mangleName();
+                        // need to incorporate scope level in order to differentiate names for destructors
+                        return decl->get_scopedMangleName();
                 } else {
                         return decl->get_name();
 …
         //*** Declarations
         void CodeGenerator::visit( FunctionDecl *functionDecl ) {
+                // generalize this
+                FunctionDecl::Attribute attr = functionDecl->get_attribute();
+                switch ( attr.type ) {
+                        case FunctionDecl::Attribute::Constructor:
+                                output << "__attribute__ ((constructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        case FunctionDecl::Attribute::Destructor:
+                                output << "__attribute__ ((destructor";
+                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
+                                        output << "(" << attr.priority << ")";
+                                }
+                                output << ")) ";
+                                break;
+                        default:
+                                break;
+                }
                 handleStorageClass( functionDecl );
                 if ( functionDecl->get_isInline() ) {
 …
                 handleStorageClass( objectDecl );
                 output << genType( objectDecl->get_type(), mangleName( objectDecl ) );
                 if ( objectDecl->get_init() ) {
                         output << " = ";
 …
                 if ( aggDecl->get_name() != "" )
                         output << aggDecl->get_name();
                 std::list< Declaration * > &memb = aggDecl->get_members();
 …
                         output << " {" << endl;
                         cur_indent += CodeGenerator::tabsize;
+                        cur_indent += CodeGenerator::tabsize;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 output << indent;
+                                output << indent;
                                 (*i)->accept( *this );
                                 output << ";" << endl;
+                        }
                         cur_indent -= CodeGenerator::tabsize;
+                        cur_indent -= CodeGenerator::tabsize;
                         output << indent << "}";
 …
                 handleAggregate( aggregateDecl );
+        }
         void CodeGenerator::visit( EnumDecl *aggDecl ) {
                 output << "enum ";
 …
                 if ( aggDecl->get_name() != "" )
                         output << aggDecl->get_name();
                 std::list< Declaration* > &memb = aggDecl->get_members();
 …
                         output << " {" << endl;
                         cur_indent += CodeGenerator::tabsize;
+                        cur_indent += CodeGenerator::tabsize;
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 ObjectDecl *obj = dynamic_cast< ObjectDecl* >( *i );
                                 assert( obj );
                                 output << indent << mangleName( obj );
+                                output << indent << mangleName( obj );
                                 if ( obj->get_init() ) {
                                         output << " = ";
 …
                         } // for
                         cur_indent -= CodeGenerator::tabsize;
+                        cur_indent -= CodeGenerator::tabsize;
                         output << indent << "}";
                 } // if
+        }
         void CodeGenerator::visit( TraitDecl *aggregateDecl ) {}
         void CodeGenerator::visit( TypedefDecl *typeDecl ) {
                 output << "typedef ";
                 output << genType( typeDecl->get_base(), typeDecl->get_name() );
+        }
         void CodeGenerator::visit( TypeDecl *typeDecl ) {
                 // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
 …
                 printDesignators( init->get_designators() );
                 output << "{ ";
+                genCommaList( init->begin_initializers(), init->end_initializers() );
+                if ( init->begin_initializers() == init->end_initializers() ) {
+                        // illegal to leave initializer list empty for scalar initializers,
+                        // but always legal to have 0
+                        output << "0";
+                } else {
+                        genCommaList( init->begin_initializers(), init->end_initializers() );
+                }
                 output << " }";
+        }
         void CodeGenerator::visit( Constant *constant ) {
+        void CodeGenerator::visit( Constant *constant ) {
                 output << constant->get_value() ;
+        }
 …
                                   case OT_POSTFIXASSIGN:
                                   case OT_INFIXASSIGN:
+                                  case OT_CTOR:
+                                  case OT_DTOR:
+                                        {
                                                 assert( arg != applicationExpr->get_args().end() );
                                                 if ( AddressExpr *addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) {
+                                                        // remove & from first assignment/ctor argument
                                                         *arg = addrExpr->get_arg();
                                                 } else {
+                                                        // no address-of operator, so must be a pointer - add dereference
                                                         UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
 …
                                                 break;
+                                        }
                                   default:
                                         // do nothing
+                                        ;
+                                }
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
 …
                                         output << "]";
                                         break;
                                   case OT_CALL:
                                         // there are no intrinsic definitions of the function call operator
                                         assert( false );
                                         break;
+                                  case OT_CTOR:
+                                  case OT_DTOR:
+                                        if ( applicationExpr->get_args().size() == 1 ) {
+                                                // the expression fed into a single parameter constructor or destructor
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
+                                                (*arg++)->accept( *this );
+                                                output << ")) /* " << opInfo.inputName << " */";
+                                        } else if ( applicationExpr->get_args().size() == 2 ) {
+                                                // intrinsic two parameter constructors are essentially bitwise assignment
+                                                output << "(";
+                                                (*arg++)->accept( *this );
+                                                output << opInfo.symbol;
+                                                (*arg)->accept( *this );
+                                                output << ") /* " << opInfo.inputName << " */";
+                                        } else {
+                                                // no constructors with 0 or more than 2 parameters
+                                                assert( false );
+                                        }
+                                        break;
                                   case OT_PREFIX:
                                   case OT_PREFIXASSIGN:
 …
                                         output << ")";
                                         break;
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
 …
                                         output << opInfo.symbol;
                                         break;
                                   case OT_INFIX:
 …
                                         output << ")";
                                         break;
                                   case OT_CONSTANT:
                                   case OT_LABELADDRESS:
 …
                 } // if
+        }
         void CodeGenerator::visit( UntypedExpr *untypedExpr ) {
                 if ( NameExpr *nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
 …
                                         output << "]";
                                         break;
                                   case OT_CALL:
                                         assert( false );
+                                        break;
+                                  case OT_CTOR:
+                                  case OT_DTOR:
+                                        if ( untypedExpr->get_args().size() == 1 ) {
+                                                // the expression fed into a single parameter constructor or destructor
+                                                // may contain side effects - output as a void expression
+                                                output << "((void)(";
+                                                (*arg++)->accept( *this );
+                                                output << ")) /* " << opInfo.inputName << " */";
+                                        } else if ( untypedExpr->get_args().size() == 2 ) {
+                                                // intrinsic two parameter constructors are essentially bitwise assignment
+                                                output << "(";
+                                                (*arg++)->accept( *this );
+                                                output << opInfo.symbol;
+                                                (*arg)->accept( *this );
+                                                output << ") /* " << opInfo.inputName << " */";
+                                        } else {
+                                                // no constructors with 0 or more than 2 parameters
+                                                assert( false );
+                                        }
+                                        break;
                                   case OT_PREFIX:
                                   case OT_PREFIXASSIGN:
 …
                                         output << ")";
                                         break;
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
 …
                                         output << opInfo.symbol;
                                         break;
                                   case OT_INFIX:
                                   case OT_INFIXASSIGN:
 …
                                         output << ")";
                                         break;
                                   case OT_CONSTANT:
                                         // there are no intrinsic definitions of 0 or 1 as functions
 …
                 } // if
+        }
         void CodeGenerator::visit( NameExpr *nameExpr ) {
                 OperatorInfo opInfo;
 …
                 } // if
+        }
         void CodeGenerator::visit( AddressExpr *addressExpr ) {
                 output << "(&";
 …
                 output << ")";
+        }
         void CodeGenerator::visit( UntypedMemberExpr *memberExpr ) {
                 assert( false );
+        }
         void CodeGenerator::visit( MemberExpr *memberExpr ) {
                 memberExpr->get_aggregate()->accept( *this );
                 output << "." << mangleName( memberExpr->get_member() );
+        }
         void CodeGenerator::visit( VariableExpr *variableExpr ) {
                 OperatorInfo opInfo;
 …
                 } // if
+        }
         void CodeGenerator::visit( ConstantExpr *constantExpr ) {
                 assert( constantExpr->get_constant() );
                 constantExpr->get_constant()->accept( *this );
+        }
         void CodeGenerator::visit( SizeofExpr *sizeofExpr ) {
                 output << "sizeof(";
 …
                 assert( false && "OffsetPackExpr should not reach code generation" );
+        }
         void CodeGenerator::visit( LogicalExpr *logicalExpr ) {
                 output << "(";
 …
                 output << ")";
+        }
         void CodeGenerator::visit( ConditionalExpr *conditionalExpr ) {
                 output << "(";
 …
                 output << ")";
+        }
         void CodeGenerator::visit( CommaExpr *commaExpr ) {
                 output << "(";
 …
                 output << ")";
+        }
         void CodeGenerator::visit( TupleExpr *tupleExpr ) {}
         void CodeGenerator::visit( TypeExpr *typeExpr ) {}
 …
+                        }
+                }
                 cur_indent -= CodeGenerator::tabsize;
+                cur_indent -= CodeGenerator::tabsize;
                 output << indent << "}";
 …
         void CodeGenerator::visit( ExprStmt *exprStmt ) {
                 // I don't see why this check is necessary.
                 // If this starts to cause problems then put it back in,
+                // I don't see why this check is necessary.
+                // If this starts to cause problems then put it back in,
                 // with an explanation
                 assert( exprStmt );
 …
                 switchStmt->get_condition()->accept( *this );
                 output << " ) ";
                 output << "{" << std::endl;
                 cur_indent += CodeGenerator::tabsize;
 …
                 } // if
                 output << ":\n";
                 std::list<Statement *> sts = caseStmt->get_statements();
 …
                         if ( ! branchStmt->get_target().empty() )
                                 output << "goto " << branchStmt->get_target();
                         else {
+                        else {
                                 if ( branchStmt->get_computedTarget() != 0 ) {
                                         output << "goto *";
 …
         void CodeGenerator::visit( ForStmt *forStmt ) {
                 // initialization is always hoisted, so don't
                 // bother doing anything with that
+                // initialization is always hoisted, so don't
+                // bother doing anything with that
                 output << "for (;";
 …
         void CodeGenerator::visit( DeclStmt *declStmt ) {
                 declStmt->get_decl()->accept( *this );
                 if ( doSemicolon( declStmt->get_decl() ) ) {
                         output << ";";

src/CodeGen/FixNames.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // FixNames.cc --
+// FixNames.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 23:36:42 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Apr 11 15:38:10 2016
 // Update Count     : 1
 //
 …
                 virtual void visit( ObjectDecl *objectDecl );
                 virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( CompoundStmt *compoundStmt );
+          private:
+                int scopeLevel = 1;
+                void fixDWT( DeclarationWithType *dwt );
         };
 …
+        }
         void fixDWT( DeclarationWithType *dwt ) {
+        void FixNames::fixDWT( DeclarationWithType *dwt ) {
                 if ( dwt->get_name() != "" ) {
                         if ( LinkageSpec::isDecoratable( dwt->get_linkage() ) ) {
                                 dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
+                                dwt->set_scopeLevel( scopeLevel );
                         } // if
                 } // if
 …
                 fixDWT( functionDecl );
+        }
+        void FixNames::visit( CompoundStmt *compoundStmt ) {
+                scopeLevel++;
+                Visitor::visit( compoundStmt );
+                scopeLevel--;
+        }
 } // namespace CodeGen

src/CodeGen/OperatorTable.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // OperatorTable.cc --
+// OperatorTable.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jun 23 17:41:14 2015
 // Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 16:48:27 2016
+// Update Count     : 9
 //
 …
                 const OperatorInfo tableValues[] = {
                         {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
+                        {       "?{}",          "=",            "_constructor",                                 OT_CTOR                         },
+                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         },
                         {       "?()",          "",             "_operator_call",                               OT_CALL                         },
                         {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },

src/CodeGen/OperatorTable.h

-              rbb8ea30
+              rd668182
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jun 23 16:09:27 2015
 // Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:17:57 2015
+// Update Count     : 5
 //
 …
         enum OperatorType {
                 OT_INDEX,
+                OT_CTOR,
+                OT_DTOR,
                 OT_CALL,
                 OT_PREFIX,

src/GenPoly/Box.cc

-              rbb8ea30
+              rd668182
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  5 16:45:07 2016
 // Update Count     : 286
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue May 03 16:44:47 2016
+// Update Count     : 295
 //
 …
                         Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
                                 TypeList typeList( params );
                                 // scan scopes for matches to the key
                                 for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
 …
                         virtual Declaration *mutate( UnionDecl *unionDecl );
                 };
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
 …
                         ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
                         ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
                         DeclarationWithType *retval;
                         bool useRetval;
 …
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
                   private:
                         void addAdapters( FunctionType *functionType );
 …
                         /// Exits the type-variable scope
                         void endTypeScope();
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
 …
                 PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
 …
                 return functionDecl;
+        }
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
 …
+                        }
+                }
                 return otypeDecls;
+        }
 …
         void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
 …
                 return makeCond( ifCond, ifExpr );
+        }
         /// adds an expression to a compound statement
         void addExpr( CompoundStmt *stmts, Expression *expr ) {
 …
                 stmts->get_kids().push_back( stmt );
+        }
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
 …
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
 …
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
+                        }
                         // place current size in the current offset index
                         addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
                                                                               derefVar( sizeParam ) ) );
                         ++n_members;
 …
                         // add member size to current size
                         addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
 …
                 return structDecl;
+        }
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
                 if ( unionDecl->get_members().empty() ) return unionDecl;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
 …
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
 …
                         assert( dwt );
                         Type *memberType = dwt->get_type();
                         // take max member size and global size
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
 …
                 return unionDecl;
+        }
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 …
                         return 0;
+                }
                 /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
                 /// Only picks assignments where neither parameter is cv-qualified
 …
                                                 Type *paramType2 = funType->get_parameters().back()->get_type();
                                                 if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
                                                 if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
                                                         Type *baseType1 = pointerType->get_base();
 …
                                                 arg++;
                                         } else {
+                                                throw SemanticError( "unbound type variable in application ", appExpr );
+                                                /// xxx - should this be an assertion?
+                                                throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr );
                                         } // if
                                 } // if
 …
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
+                        }
                         // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
 …
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
                         // add out-parameter for return value
+                        // add out-parameter for return value
                         return addRetParam( appExpr, function, concrete, arg );
+                }
 …
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        // xxx - need to test that this code is still reachable
                                         if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
                                                 commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
 …
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
+                                // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
+                                //      std::cerr << i->first << " ";
+                                // }
+                                // std::cerr << "\n";
+                                // printTyVarMap( std::cerr, scopeTyVars );
+                                // std::cerr << *env << std::endl;
                                 // change the application so it calls the adapter rather than the passed function
                                 ret = applyAdapter( appExpr, function, arg, scopeTyVars );
 …
                                 } // if
                         } // if
+                        // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
+                        // out of the if condition.
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env ) || needs ) {
+                        if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
                                 delete ret->get_results().front();
 …
                         return new VariableExpr( functionObj );
+                }
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
 …
+                                }
+                        }
                         Type *ret = Mutator::mutate( funcType );
 …
                                         std::list<Expression*> designators;
                                         objectDecl->set_init( new SingleInit( alloc, designators ) );
+                                        objectDecl->set_init( new SingleInit( alloc, designators, false ) ); // not constructed
+                                }
+                        }
 …
                         return derefdVar;
+                }
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
 …
                                 if ( n_members == 0 ) {
                                         // all empty structs have the same layout - size 1, align 1
                                         makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
                                         makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
+                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                                         // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
                                 } else {
                                         ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
                                         ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
                                         ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from_int( n_members ) ), false, false ) );
                                         // generate call to layout function
 …
                         Type *ty = offsetofExpr->get_type();
                         if ( ! findGeneric( ty ) ) return offsetofExpr;
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
 …
                                         // build the offset array and replace the pack with a reference to it
                                         ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from_ulong( baseMembers.size() ) ), false, false ),
                                                         new ListInit( inits ) );
                                         ret = new VariableExpr( offsetArray );

src/GenPoly/CopyParams.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // CopyParams.cc --
+// CopyParams.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
+// Last Modified By : Rob Schluntz
 // Last Modified On : Tue May 19 07:33:31 2015
 // Update Count     : 1
 …
           public:
                 CopyParams();
                 virtual void visit( FunctionDecl *funcDecl );
                 virtual void visit( AddressExpr *addrExpr );
 …
                 if ( funcDecl->get_statements() ) {
                         funcDecl->get_statements()->accept( *this );
                         if ( ! modVars.empty() ) {
                                 std::map< std::string, DeclarationWithType* > assignOps;
 …
                                         if ( (*tyVar)->get_kind() == TypeDecl::Any ) {
                                                 assert( !(*tyVar)->get_assertions().empty() );
+                                                assert( (*tyVar)->get_assertions().front()->get_name() == "?=?" );
                                                 assignOps[ (*tyVar)->get_name() ] = (*tyVar)->get_assertions().front();
                                         } // if

src/GenPoly/GenPoly.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // GenPoly.cc --
+// GenPoly.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec 15 16:11:18 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon May 02 14:53:33 2016
 // Update Count     : 13
 //
 …
                 return 0;
+        }
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
 …
                 return 0;
+        }
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
 …
                 return isPolyType( type, env );
+        }
         Type * hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels, const TypeSubstitution *env ) {
                 int dummy;
 …
                                 if ( ! fn || fn->get_name() != std::string("*?") ) return 0;
                                 expr = *untypedExpr->begin_args();
+                        } else if ( CommaExpr *commaExpr = dynamic_cast< CommaExpr* >( expr ) ) {
+                                // copy constructors insert comma exprs, look at second argument which contains the variable
+                                expr = commaExpr->get_arg2();
+                                continue;
                         } else break;
 …
+                }
+        }
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/PolyMutator.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // PolyMutator.cc --
+// PolyMutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri Aug 14 15:28:50 2015
+// Last Modified On : Mon May 02 14:50:58 2016
 // Update Count     : 11
 //
 …
                                 env = expr->get_env();
+                        }
+                        // xxx - should env be cloned (or moved) onto the result of the mutate?
                         return expr->acceptMutator( *this );
                 } else {
 …
                 return untypedExpr;
+        }
         Initializer *PolyMutator::mutate( SingleInit *singleInit ) {
                 singleInit->set_value( mutateExpression( singleInit->get_value() ) );

src/GenPoly/Specialize.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Jan 20 12:40:33 2016
 // Update Count     : 18
+// Last Modified On : Thu Apr 28 15:17:45 2016
+// Update Count     : 24
 //
 …
                 virtual Expression * mutate( AddressExpr *castExpr );
                 virtual Expression * mutate( CastExpr *castExpr );
                 virtual Expression * mutate( LogicalExpr *logicalExpr );
                 virtual Expression * mutate( ConditionalExpr *conditionalExpr );
                 virtual Expression * mutate( CommaExpr *commaExpr );
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
           private:
 …
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assert( ! actual->get_results().empty() );
+                assert( ! actual->get_results().empty() ); // using front, should have this assert
                 if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
                         FunctionType *funType;
 …
+        }
+        Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
+                return logicalExpr;
+        }
+        Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
+                return condExpr;
+        }
+        Expression * Specialize::mutate( CommaExpr *commaExpr ) {
+                return commaExpr;
+        }
+        // Removing these for now. Richard put these in for some reason, but it's not clear why.
+        // In particular, copy constructors produce a comma expression, and with this code the parts
+        // of that comma expression are not specialized, which causes problems.
+        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
+        //      return logicalExpr;
+        // }
+        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
+        //      return condExpr;
+        // }
+        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
+        //      return commaExpr;
+        // }
 } // namespace GenPoly

src/InitTweak/InitModel.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // InitModel.cc --
+// InitModel.cc --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 19 16:37:08 2015
 // Update Count     : 1
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jan 07 13:38:46 2016
+// Update Count     : 5
 //
 …
                 assert(init == 0 && single != 0);
                 std::list< Expression * > empty;
                 init = new SingleInit( single->get_expr(), empty );
+                init = new SingleInit( single->get_expr(), empty, false ); // cannot be constructed
                 return;
+        }
 …
                         } // if
+                init = new ListInit( contents );
+                std::list< Expression * > desig;
+                init = new ListInit( contents, desig, false ); // cannot be constructed
                 return;
+        }

src/InitTweak/module.mk

-              rbb8ea30
+              rd668182
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Rob Schluntz
 ## Last Modified On : Mon Jan 11 14:40:16 2016
 ## Update Count     : 2
+## Last Modified On : Fri May 13 11:36:24 2016
+## Update Count     : 3
 ###############################################################################
+SRC += InitTweak/RemoveInit.cc
+SRC += InitTweak/GenInit.cc \
+        InitTweak/FixInit.cc \
+        InitTweak/FixGlobalInit.cc \
+        InitTweak/InitTweak.cc

src/MakeLibCfa.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // MakeLibCfa.cc --
+// MakeLibCfa.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 10:33:33 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun 26 16:52:59 2015
 // Update Count     : 14
 //
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 22 13:54:15 2016
+// Update Count     : 40
+//
 #include "MakeLibCfa.h"
 …
                 void visit( FunctionDecl* funcDecl );
                 void visit( ObjectDecl* objDecl );
                 std::list< Declaration* > &get_newDecls() { return newDecls; }
           private:
 …
         void MakeLibCfa::visit( FunctionDecl* origFuncDecl ) {
                 if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+                if ( origFuncDecl->get_statements() ) return;
                 FunctionDecl *funcDecl = origFuncDecl->clone();
                 CodeGen::OperatorInfo opInfo;
 …
                 assert( param != funcDecl->get_functionType()->get_parameters().end() );
+                if ( (*param)->get_name() == "" ) {
+                        (*param)->set_name( paramNamer.newName() );
+                        (*param)->set_linkage( LinkageSpec::C );
+                } // if
+                for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
+                        if ( (*param)->get_name() == "" ) {
+                                (*param)->set_name( paramNamer.newName() );
+                                (*param)->set_linkage( LinkageSpec::C );
+                        }
+                        newExpr->get_args().push_back( new VariableExpr( *param ) );
+                } // for
+                funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+                newDecls.push_back( funcDecl );
                 switch ( opInfo.type ) {
 …
                   case CodeGen::OT_POSTFIX:
                   case CodeGen::OT_INFIX:
-                        newExpr->get_args().push_back( new VariableExpr( *param ) );
-                        break;
                   case CodeGen::OT_PREFIXASSIGN:
                   case CodeGen::OT_POSTFIXASSIGN:
                   case CodeGen::OT_INFIXASSIGN:
+                        {
+                                newExpr->get_args().push_back( new VariableExpr( *param ) );
+                                // UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                // deref->get_args().push_back( new VariableExpr( *param ) );
+                                // newExpr->get_args().push_back( deref );
+                                funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
                                 break;
+                        }
+                  case CodeGen::OT_CTOR:
+                        // ctors don't return a value
+                        if ( funcDecl->get_functionType()->get_parameters().size() == 1 ) {
+                                // intrinsic default constructors should do nothing
+                                // delete newExpr;
+                                break;
+                        } else {
+                                assert( funcDecl->get_functionType()->get_parameters().size() == 2 );
+                                // anything else is a single parameter constructor that is effectively a C-style assignment
+                                // delete newExpr->get_function();
+                                assert(newExpr->get_args().size()==2);
+                                newExpr->set_function( new NameExpr( "?=?" ) );
+                                funcDecl->get_statements()->get_kids().push_back( new ExprStmt( std::list< Label >(), newExpr ) );
+                        }
+                        break;
+                  case CodeGen::OT_DTOR:
+                        // intrinsic destructors should do nothing
+                        // delete newExpr;
+                        break;
                   case CodeGen::OT_CONSTANT:
                   case CodeGen::OT_LABELADDRESS:
 …
                         assert( false );
                 } // switch
-                for ( param++; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
-                        if ( (*param)->get_name() == "" ) {
-                                (*param)->set_name( paramNamer.newName() );
-                                (*param)->set_linkage( LinkageSpec::C );
+                        }
-                        newExpr->get_args().push_back( new VariableExpr( *param ) );
-                } // for
-                funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
-                funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
-                newDecls.push_back( funcDecl );
+        }
         void MakeLibCfa::visit( ObjectDecl* origObjDecl ) {
                 if ( origObjDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
                 ObjectDecl *objDecl = origObjDecl->clone();
                 assert( ! objDecl->get_init() );
                 std::list< Expression* > noDesignators;
                 objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators ) );
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed
                 newDecls.push_back( objDecl );
+        }
 } // namespace LibCfa
-// Local Variables: //
-// tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
-// End: //

src/Makefile.in

-              rbb8ea30
+              rd668182
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
+        InitTweak/driver_cfa_cpp-RemoveInit.$(OBJEXT) \
+        InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
+        InitTweak/driver_cfa_cpp-FixInit.$(OBJEXT) \
+        InitTweak/driver_cfa_cpp-FixGlobalInit.$(OBJEXT) \
+        InitTweak/driver_cfa_cpp-InitTweak.$(OBJEXT) \
         Parser/driver_cfa_cpp-parser.$(OBJEXT) \
         Parser/driver_cfa_cpp-lex.$(OBJEXT) \
 …
         SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT) \
         SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT) \
+        SymTab/driver_cfa_cpp-Autogen.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Type.$(OBJEXT) \
         SynTree/driver_cfa_cpp-VoidType.$(OBJEXT) \
 …
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
         GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
+        GenPoly/DeclMutator.cc InitTweak/RemoveInit.cc \
+        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
+        Parser/ParseNode.cc Parser/DeclarationNode.cc \
+        Parser/ExpressionNode.cc Parser/StatementNode.cc \
+        Parser/InitializerNode.cc Parser/TypeData.cc \
+        Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \
+        GenPoly/DeclMutator.cc InitTweak/GenInit.cc \
+        InitTweak/FixInit.cc InitTweak/FixGlobalInit.cc \
+        InitTweak/InitTweak.cc Parser/parser.yy Parser/lex.ll \
+        Parser/TypedefTable.cc Parser/ParseNode.cc \
+        Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
+        Parser/StatementNode.cc Parser/InitializerNode.cc \
+        Parser/TypeData.cc Parser/LinkageSpec.cc \
+        Parser/parseutility.cc Parser/Parser.cc \
         ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
         ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
 …
         SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
         SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
+        SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
+        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
+        SynTree/BasicType.cc SynTree/PointerType.cc \
+        SynTree/ArrayType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/Constant.cc \
         SynTree/Expression.cc SynTree/TupleExpr.cc \
 …
         @$(MKDIR_P) InitTweak/$(DEPDIR)
         @: > InitTweak/$(DEPDIR)/$(am__dirstamp)
+InitTweak/driver_cfa_cpp-RemoveInit.$(OBJEXT):  \
+InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
+        InitTweak/$(DEPDIR)/$(am__dirstamp)
+InitTweak/driver_cfa_cpp-FixInit.$(OBJEXT): InitTweak/$(am__dirstamp) \
+        InitTweak/$(DEPDIR)/$(am__dirstamp)
+InitTweak/driver_cfa_cpp-FixGlobalInit.$(OBJEXT):  \
+        InitTweak/$(am__dirstamp) InitTweak/$(DEPDIR)/$(am__dirstamp)
+InitTweak/driver_cfa_cpp-InitTweak.$(OBJEXT):  \
         InitTweak/$(am__dirstamp) InitTweak/$(DEPDIR)/$(am__dirstamp)
 Parser/parser.h: Parser/parser.cc
 …
 SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/driver_cfa_cpp-Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
 SynTree/$(am__dirstamp):
         @$(MKDIR_P) SynTree
 …
         -rm -f GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT)
         -rm -f GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT)
+        -rm -f InitTweak/driver_cfa_cpp-RemoveInit.$(OBJEXT)
+        -rm -f InitTweak/driver_cfa_cpp-FixGlobalInit.$(OBJEXT)
+        -rm -f InitTweak/driver_cfa_cpp-FixInit.$(OBJEXT)
+        -rm -f InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT)
+        -rm -f InitTweak/driver_cfa_cpp-InitTweak.$(OBJEXT)
         -rm -f Parser/driver_cfa_cpp-DeclarationNode.$(OBJEXT)
         -rm -f Parser/driver_cfa_cpp-ExpressionNode.$(OBJEXT)
 …
         -rm -f ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT)
         -rm -f ResolvExpr/driver_cfa_cpp-Unify.$(OBJEXT)
+        -rm -f SymTab/driver_cfa_cpp-Autogen.$(OBJEXT)
         -rm -f SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT)
         -rm -f SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-DeclarationNode.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-ExpressionNode.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-TypeEnvironment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Unify.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-FixFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po@am__quote@
 …
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
+InitTweak/driver_cfa_cpp-RemoveInit.o: InitTweak/RemoveInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-RemoveInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Tpo -c -o InitTweak/driver_cfa_cpp-RemoveInit.o `test -f 'InitTweak/RemoveInit.cc' || echo '$(srcdir)/'`InitTweak/RemoveInit.cc
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/RemoveInit.cc' object='InitTweak/driver_cfa_cpp-RemoveInit.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-RemoveInit.o `test -f 'InitTweak/RemoveInit.cc' || echo '$(srcdir)/'`InitTweak/RemoveInit.cc
+InitTweak/driver_cfa_cpp-RemoveInit.obj: InitTweak/RemoveInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-RemoveInit.obj -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Tpo -c -o InitTweak/driver_cfa_cpp-RemoveInit.obj `if test -f 'InitTweak/RemoveInit.cc'; then $(CYGPATH_W) 'InitTweak/RemoveInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/RemoveInit.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-RemoveInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/RemoveInit.cc' object='InitTweak/driver_cfa_cpp-RemoveInit.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-RemoveInit.obj `if test -f 'InitTweak/RemoveInit.cc'; then $(CYGPATH_W) 'InitTweak/RemoveInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/RemoveInit.cc'; fi`
+InitTweak/driver_cfa_cpp-GenInit.o: InitTweak/GenInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-GenInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo -c -o InitTweak/driver_cfa_cpp-GenInit.o `test -f 'InitTweak/GenInit.cc' || echo '$(srcdir)/'`InitTweak/GenInit.cc
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/GenInit.cc' object='InitTweak/driver_cfa_cpp-GenInit.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-GenInit.o `test -f 'InitTweak/GenInit.cc' || echo '$(srcdir)/'`InitTweak/GenInit.cc
+InitTweak/driver_cfa_cpp-GenInit.obj: InitTweak/GenInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-GenInit.obj -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo -c -o InitTweak/driver_cfa_cpp-GenInit.obj `if test -f 'InitTweak/GenInit.cc'; then $(CYGPATH_W) 'InitTweak/GenInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/GenInit.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-GenInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/GenInit.cc' object='InitTweak/driver_cfa_cpp-GenInit.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-GenInit.obj `if test -f 'InitTweak/GenInit.cc'; then $(CYGPATH_W) 'InitTweak/GenInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/GenInit.cc'; fi`
+InitTweak/driver_cfa_cpp-FixInit.o: InitTweak/FixInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-FixInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Tpo -c -o InitTweak/driver_cfa_cpp-FixInit.o `test -f 'InitTweak/FixInit.cc' || echo '$(srcdir)/'`InitTweak/FixInit.cc
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/FixInit.cc' object='InitTweak/driver_cfa_cpp-FixInit.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-FixInit.o `test -f 'InitTweak/FixInit.cc' || echo '$(srcdir)/'`InitTweak/FixInit.cc
+InitTweak/driver_cfa_cpp-FixInit.obj: InitTweak/FixInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-FixInit.obj -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Tpo -c -o InitTweak/driver_cfa_cpp-FixInit.obj `if test -f 'InitTweak/FixInit.cc'; then $(CYGPATH_W) 'InitTweak/FixInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/FixInit.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-FixInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/FixInit.cc' object='InitTweak/driver_cfa_cpp-FixInit.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-FixInit.obj `if test -f 'InitTweak/FixInit.cc'; then $(CYGPATH_W) 'InitTweak/FixInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/FixInit.cc'; fi`
+InitTweak/driver_cfa_cpp-FixGlobalInit.o: InitTweak/FixGlobalInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-FixGlobalInit.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Tpo -c -o InitTweak/driver_cfa_cpp-FixGlobalInit.o `test -f 'InitTweak/FixGlobalInit.cc' || echo '$(srcdir)/'`InitTweak/FixGlobalInit.cc
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/FixGlobalInit.cc' object='InitTweak/driver_cfa_cpp-FixGlobalInit.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-FixGlobalInit.o `test -f 'InitTweak/FixGlobalInit.cc' || echo '$(srcdir)/'`InitTweak/FixGlobalInit.cc
+InitTweak/driver_cfa_cpp-FixGlobalInit.obj: InitTweak/FixGlobalInit.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-FixGlobalInit.obj -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Tpo -c -o InitTweak/driver_cfa_cpp-FixGlobalInit.obj `if test -f 'InitTweak/FixGlobalInit.cc'; then $(CYGPATH_W) 'InitTweak/FixGlobalInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/FixGlobalInit.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-FixGlobalInit.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/FixGlobalInit.cc' object='InitTweak/driver_cfa_cpp-FixGlobalInit.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-FixGlobalInit.obj `if test -f 'InitTweak/FixGlobalInit.cc'; then $(CYGPATH_W) 'InitTweak/FixGlobalInit.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/FixGlobalInit.cc'; fi`
+InitTweak/driver_cfa_cpp-InitTweak.o: InitTweak/InitTweak.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-InitTweak.o -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Tpo -c -o InitTweak/driver_cfa_cpp-InitTweak.o `test -f 'InitTweak/InitTweak.cc' || echo '$(srcdir)/'`InitTweak/InitTweak.cc
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/InitTweak.cc' object='InitTweak/driver_cfa_cpp-InitTweak.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-InitTweak.o `test -f 'InitTweak/InitTweak.cc' || echo '$(srcdir)/'`InitTweak/InitTweak.cc
+InitTweak/driver_cfa_cpp-InitTweak.obj: InitTweak/InitTweak.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/driver_cfa_cpp-InitTweak.obj -MD -MP -MF InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Tpo -c -o InitTweak/driver_cfa_cpp-InitTweak.obj `if test -f 'InitTweak/InitTweak.cc'; then $(CYGPATH_W) 'InitTweak/InitTweak.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/InitTweak.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Tpo InitTweak/$(DEPDIR)/driver_cfa_cpp-InitTweak.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='InitTweak/InitTweak.cc' object='InitTweak/driver_cfa_cpp-InitTweak.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o InitTweak/driver_cfa_cpp-InitTweak.obj `if test -f 'InitTweak/InitTweak.cc'; then $(CYGPATH_W) 'InitTweak/InitTweak.cc'; else $(CYGPATH_W) '$(srcdir)/InitTweak/InitTweak.cc'; fi`
 Parser/driver_cfa_cpp-parser.o: Parser/parser.cc
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TypeEquality.obj `if test -f 'SymTab/TypeEquality.cc'; then $(CYGPATH_W) 'SymTab/TypeEquality.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TypeEquality.cc'; fi`
+SymTab/driver_cfa_cpp-Autogen.o: SymTab/Autogen.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Autogen.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Tpo -c -o SymTab/driver_cfa_cpp-Autogen.o `test -f 'SymTab/Autogen.cc' || echo '$(srcdir)/'`SymTab/Autogen.cc
+@am__fastdepCXX_TRUE@   $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SymTab/Autogen.cc' object='SymTab/driver_cfa_cpp-Autogen.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-Autogen.o `test -f 'SymTab/Autogen.cc' || echo '$(srcdir)/'`SymTab/Autogen.cc
+SymTab/driver_cfa_cpp-Autogen.obj: SymTab/Autogen.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Autogen.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Tpo -c -o SymTab/driver_cfa_cpp-Autogen.obj `if test -f 'SymTab/Autogen.cc'; then $(CYGPATH_W) 'SymTab/Autogen.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/Autogen.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SymTab/Autogen.cc' object='SymTab/driver_cfa_cpp-Autogen.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-Autogen.obj `if test -f 'SymTab/Autogen.cc'; then $(CYGPATH_W) 'SymTab/Autogen.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/Autogen.cc'; fi`
 SynTree/driver_cfa_cpp-Type.o: SynTree/Type.cc

src/Parser/DeclarationNode.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // DeclarationNode.cc --
+// DeclarationNode.cc --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 13 16:53:17 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:38:09 2016
 // Update Count     : 161
 //
 …
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
+                os << " maybe constructed? " << initializer->get_maybeConstructed();
         } // if
 …
         } // if
+}
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
 …
                 assert( false );
         } // switch
         return this;
+}
 …
                 assert( a->type->kind == TypeData::Array );
                 TypeData *lastArray = findLast( a->type );
                 if ( type ) {
+                if ( type ) {
                         switch ( type->kind ) {
                           case TypeData::Aggregate:
 …
         } // if
+}
 DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
         type = addIdListToType( type, ids );
 …
 Type *DeclarationNode::buildType() const {
         assert( type );
         switch ( type->kind ) {
           case TypeData::Enum:

src/Parser/InitializerNode.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // InitializerNode.cc --
 //
+// InitializerNode.cc --
+//
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Oct  8 17:18:55 2015
 // Update Count     : 4
 //
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Jan 07 13:32:57 2016
+// Update Count     : 13
+//
 #include <cassert>
 …
 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
         : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ) {
+        : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( aggrp )
                 kids = dynamic_cast< InitializerNode *>( get_link() );
 …
 InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
         : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ) {
+        : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
         if ( init != 0 )
                 set_link(init);
 …
                 } // if
                 return new ListInit( initlist, designlist );
+                return new ListInit( initlist, designlist, maybeConstructed );
         } else {
                 std::list< Expression *> designators;
 …
                 if ( get_expression() != 0)
                         return new SingleInit( get_expression()->build(), designators );
+                        return new SingleInit( get_expression()->build(), designators, maybeConstructed );
         } // if

src/Parser/ParseNode.h

-              rbb8ea30
+              rd668182
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Mon Apr 11 11:50:52 2016
+// Last Modified On : Thu Apr 14 15:37:52 2016
 // Update Count     : 205
 //
 …
                                 // monadic
                                 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
+                                Ctor, Dtor,
         };
 …
         ExpressionNode *get_designators() const { return designator; }
+        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
+        bool get_maybeConstructed() const { return maybeConstructed; }
         InitializerNode *next_init() const { return kids; }
 …
         ExpressionNode *designator; // may be list
         InitializerNode *kids;
+        bool maybeConstructed;
 };

src/Parser/TypeData.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // TypeData.cc --
+// TypeData.cc --
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:26:45 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 06 16:57:53 2016
 // Update Count     : 49
 //
 …
         for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
                 if ( (*i)->get_kind() == TypeDecl::Any ) {
+                        // add assertion parameters to `type' tyvars in reverse order
+                        // add dtor:  void ^?{}(T *)
+                        FunctionType *dtorType = new FunctionType( Type::Qualifiers(), false );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );
+                        // add copy ctor:  void ?{}(T *, T)
+                        FunctionType *copyCtorType = new FunctionType( Type::Qualifiers(), false );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );
+                        // add default ctor:  void ?{}(T *)
+                        FunctionType *ctorType = new FunctionType( Type::Qualifiers(), false );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );
+                        // add assignment operator:  T * ?=?(T *, T)
                         FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
 …
                 if ( cur->get_enumeratorValue() != NULL ) {
                         ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);
                         member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ) ) );
+                        member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ), std::list< Expression * >() ) );
                 } // if
         } // for

src/Parser/parser.cc

rbb8ea30	rd668182
7468	7468	/* Line 1806 of yacc.c */
7469	7469	#line 1704 "parser.yy"
7470		{ (yyval.in) = (yyvsp[(2) - (2)].in); }
	7470	{ (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
7471	7471	break;
7472	7472

src/Parser/parser.yy

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // cfa.y --
 //
+// cfa.y --
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
 …
 // Last Modified On : Wed Apr 13 16:58:43 2016
 // Update Count     : 1519
 //
+//
 // This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the C
 …
                 { $$ = $2; }
         | ATassign initializer
                 { $$ = $2; }
+                { $$ = $2->set_maybeConstructed( false ); }
+        ;

src/ResolvExpr/AlternativeFinder.cc

-              rbb8ea30
+              rd668182
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Feb 10 17:00:04 2016
+// Last Modified On : Wed Apr 20 14:24:03 2016
 // Update Count     : 24
 //
 …
                 } // for
+        }
+        void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
+        }
 } // namespace ResolvExpr

src/ResolvExpr/AlternativeFinder.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // AlternativeFinder.h --
+// AlternativeFinder.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:56:12 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 16 23:58:43 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 19 11:44:53 2016
 // Update Count     : 2
 //
+//
 #ifndef ALTERNATIVEFINDER_H
 …
                 virtual void visit( NameExpr *variableExpr );
                 virtual void visit( VariableExpr *variableExpr );
                 virtual void visit( ConstantExpr *constantExpr );
+                virtual void visit( ConstantExpr *constantExpr );
                 virtual void visit( SizeofExpr *sizeofExpr );
                 virtual void visit( AlignofExpr *alignofExpr );
 …
                 virtual void visit( CommaExpr *commaExpr );
                 virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
           public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
                 template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/Resolver.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Resolver.cc --
+// Resolver.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 24 16:43:11 2016
 // Update Count     : 181
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:36:40 2016
+// Update Count     : 203
 //
 …
 #include "SymTab/Indexer.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 #include <iostream>
 …
           public:
                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
                 virtual void visit( FunctionDecl *functionDecl );
                 virtual void visit( ObjectDecl *functionDecl );
 …
                 virtual void visit( SingleInit *singleInit );
                 virtual void visit( ListInit *listInit );
+                virtual void visit( ConstructorInit *ctorInit );
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
 …
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
+          void fallbackInit( ConstructorInit * ctorInit );
                 std::list< Type * > functionReturn;
                 Type *initContext;
 …
+        }
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
 …
                         env.makeSubstitution( *expr->get_env() );
+                }
+                Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                        global_renamer.reset();
+                        TypeEnvironment env;
+                        Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                        finishExpr( newExpr, env );
+                        return newExpr;
+                }
+        } // namespace
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                global_renamer.reset();
+                TypeEnvironment env;
+                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                finishExpr( newExpr, env );
+                return newExpr;
+        }
+        namespace {
                 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
 …
                         } // if
+                }
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
 …
                         return newExpr;
+                }
+        }
+        }
         void Resolver::visit( ObjectDecl *objectDecl ) {
                 Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
 …
                         forStmt->set_condition( newExpr );
                 } // if
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
 …
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
                 visitor.Visitor::visit( switchStmt );
+        }
 …
         bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
+                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
                                 bt->get_kind() == BasicType::UnsignedChar;
+                }
 …
                                 string n = ne->get_name();
                                 if (n == "0") {
                                         initContext = new BasicType(Type::Qualifiers(),
+                                        initContext = new BasicType(Type::Qualifiers(),
                                                                                                 BasicType::SignedInt);
                                 } else {
 …
                                         initContext = decl->get_type();
+                                }
                         } else if (ConstantExpr * e =
+                        } else if (ConstantExpr * e =
                                            dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
                                 Constant *c = e->get_constant();
 …
                                                         singleInit->set_value( ce->get_arg() );
                                                         ce->set_arg( NULL );
                                                         delete ce;
+                                                        delete ce;
+                                                }
+                                        }
 …
 #endif
+        }
+        // ConstructorInit - fall back on C-style initializer
+        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
+                // could not find valid constructor, or found an intrinsic constructor
+                // fall back on C-style initializer
+                delete ctorInit->get_ctor();
+                ctorInit->set_ctor( NULL );
+                maybeAccept( ctorInit->get_init(), *this );
+        }
+        void Resolver::visit( ConstructorInit *ctorInit ) {
+                try {
+                        maybeAccept( ctorInit->get_ctor(), *this );
+                        maybeAccept( ctorInit->get_dtor(), *this );
+                } catch ( SemanticError ) {
+                        // no alternatives for the constructor initializer - fallback on C-style initializer
+                        // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        fallbackInit( ctorInit );
+                        return;
+                }
+                // found a constructor - can get rid of C-style initializer
+                delete ctorInit->get_init();
+                ctorInit->set_init( NULL );
+                // intrinsic single parameter constructors and destructors do nothing. Since this was
+                // implicitly generated, there's no way for it to have side effects, so get rid of it
+                // to clean up generated code.
+                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                        delete ctorInit->get_ctor();
+                        ctorInit->set_ctor( NULL );
+                }
+                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                        delete ctorInit->get_dtor();
+                        ctorInit->set_dtor( NULL );
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/Resolver.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Resolver.h --
+// Resolver.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun May 17 12:19:32 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:06:53 2016
 // Update Count     : 2
 //
 …
         void resolve( std::list< Declaration * > translationUnit );
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
 } // namespace ResolvExpr

src/SymTab/AddVisit.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // AddVisit.h --
+// AddVisit.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 16:14:32 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr  7 14:42:21 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:52:42 2016
 // Update Count     : 5
 //
 …
         //      maybeAccept( caseStmt->get_condition(), visitor );
         // }
+        template< typename Visitor >
+        void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
+                std::list< Declaration * >::iterator i = translationUnit.begin();
+                while ( i != translationUnit.end() ) {
+                        (*i)->accept( visitor );
+                        std::list< Declaration * >::iterator next = i;
+                        next++;
+                        if ( ! visitor.get_declsToAdd().empty() ) {
+                                translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
+                        } // if
+                        i = next;
+                } // while
+        }
 } // namespace SymTab

src/SymTab/Validate.cc

-              rbb8ea30
+              rd668182
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 13 16:39:30 2016
 // Update Count     : 251
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed May 11 13:17:52 2016
+// Update Count     : 297
 //
 …
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
+#include "Autogen.h"
 #include "ResolvExpr/typeops.h"
 …
                 const Indexer *indexer;
-        };
-        class AutogenerateRoutines : public Visitor {
-          public:
-                /// Generates assignment operators for aggregate types as required
-                static void autogenerateRoutines( std::list< Declaration * > &translationUnit );
-                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-                virtual void visit( EnumDecl *enumDecl );
-                virtual void visit( StructDecl *structDecl );
-                virtual void visit( UnionDecl *structDecl );
-                virtual void visit( TypeDecl *typeDecl );
-                virtual void visit( TraitDecl *ctxDecl );
-                virtual void visit( FunctionDecl *functionDecl );
-                virtual void visit( FunctionType *ftype );
-                virtual void visit( PointerType *ftype );
-                virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( SwitchStmt *switchStmt );
-                virtual void visit( ChooseStmt *chooseStmt );
-                // virtual void visit( CaseStmt *caseStmt );
-                AutogenerateRoutines() : functionNesting( 0 ) {}
-          private:
-                template< typename StmtClass > void visitStatement( StmtClass *stmt );
-                std::list< Declaration * > declsToAdd;
-                std::set< std::string > structsDone;
-                unsigned int functionNesting;                   // current level of nested functions
         };
 …
                 template<typename AggDecl>
                 void addImplicitTypedef( AggDecl * aggDecl );
                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
                 TypedefMap typedefNames;
                 int scopeLevel;
         };
+        class VerifyCtorDtor : public Visitor {
+        public:
+                /// ensure that constructors and destructors have at least one
+                /// parameter, the first of which must be a pointer, and no
+                /// return values.
+                static void verify( std::list< Declaration * > &translationUnit );
+                virtual void visit( FunctionDecl *funcDecl );
+};
         class CompoundLiteral : public GenPoly::DeclMutator {
 …
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
+                autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
+                VerifyCtorDtor::verify( translationUnit );
+        }
 …
                 type->accept( pass2 );
                 type->accept( pass3 );
+        }
-        template< typename Visitor >
-        void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
-                std::list< Declaration * >::iterator i = translationUnit.begin();
-                while ( i != translationUnit.end() ) {
-                        (*i)->accept( visitor );
-                        std::list< Declaration * >::iterator next = i;
-                        next++;
-                        if ( ! visitor.get_declsToAdd().empty() ) {
-                                translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
-                        } // if
-                        i = next;
-                } // while
+        }
 …
+        }
-        static const std::list< std::string > noLabels;
-        void AutogenerateRoutines::autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                AutogenerateRoutines visitor;
-                acceptAndAdd( translationUnit, visitor, false );
+        }
-        template< typename OutputIterator >
-        void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
-                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
-                // unnamed bit fields are not copied as they cannot be accessed
-                if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
-                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
-                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
-                // do something special for unnamed members
-                Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
-                assignExpr->get_args().push_back( dstselect );
-                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
-                assignExpr->get_args().push_back( srcselect );
-                *out++ = new ExprStmt( noLabels, assignExpr );
+        }
-        template< typename OutputIterator >
-        void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
-                static UniqueName indexName( "_index" );
-                // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->get_dimension() ) return;
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
-                *out++ = new DeclStmt( noLabels, index );
-                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
-                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
-                init->get_args().push_back( new NameExpr( "0" ) );
-                Statement *initStmt = new ExprStmt( noLabels, init );
-                std::list<Statement *> initList;
-                initList.push_back( initStmt );
-                UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
-                cond->get_args().push_back( new VariableExpr( index ) );
-                cond->get_args().push_back( array->get_dimension()->clone() );
-                UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
-                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
-                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
-                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
-                Expression *dstselect = new MemberExpr( member, derefExpr );
-                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
-                dstIndex->get_args().push_back( dstselect );
-                dstIndex->get_args().push_back( new VariableExpr( index ) );
-                assignExpr->get_args().push_back( dstIndex );
-                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
-                UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
-                srcIndex->get_args().push_back( srcselect );
-                srcIndex->get_args().push_back( new VariableExpr( index ) );
-                assignExpr->get_args().push_back( srcIndex );
-                *out++ = new ForStmt( noLabels, initList, cond, inc, new ExprStmt( noLabels, assignExpr ) );
+        }
-        template< typename OutputIterator >
-        void makeUnionFieldsAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, UnionInstType *unionType, OutputIterator out ) {
-                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
-                copy->get_args().push_back( new VariableExpr( dstParam ) );
-                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
-                copy->get_args().push_back( new SizeofExpr( unionType ) );
-                *out++ = new ExprStmt( noLabels, copy );
+        }
-        //E ?=?(E volatile*, int),
-        //  ?=?(E _Atomic volatile*, int);
-        void makeEnumAssignment( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
-                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
-                assignType->get_returnVals().push_back( returnVal );
-                // need two assignment operators with different types
-                FunctionType * assignType2 = assignType->clone();
-                // E ?=?(E volatile *, E)
-                Type *etype = refType->clone();
-                // etype->get_qualifiers() += Type::Qualifiers(false, true, false, false, false, false);
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), etype ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, etype->clone(), 0 );
-                assignType->get_parameters().push_back( srcParam );
-                // E ?=?(E volatile *, int)
-                assignType2->get_parameters().push_back( dstParam->clone() );
-                BasicType * paramType = new BasicType(Type::Qualifiers(), BasicType::SignedInt);
-                ObjectDecl *srcParam2 = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, paramType, 0 );
-                assignType2->get_parameters().push_back( srcParam2 );
-                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
-                // because each unit generates copies of the default routines for each aggregate.
-                // since there is no definition, these should not be inline
-                // make these intrinsic so that the code generator does not make use of them
-                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType, 0, false, false );
-                assignDecl->fixUniqueId();
-                FunctionDecl *assignDecl2 = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType2, 0, false, false );
-                assignDecl2->fixUniqueId();
-                // these should be built in the same way that the prelude
-                // functions are, so build a list containing the prototypes
-                // and allow MakeLibCfa to autogenerate the bodies.
-                std::list< Declaration * > assigns;
-                assigns.push_back( assignDecl );
-                assigns.push_back( assignDecl2 );
-                LibCfa::makeLibCfa( assigns );
-                // need to remove the prototypes, since this may be nested in a routine
-                for (int start = 0, end = assigns.size()/2; start < end; start++) {
-                        delete assigns.front();
-                        assigns.pop_front();
-                } // for
-                declsToAdd.insert( declsToAdd.begin(), assigns.begin(), assigns.end() );
+        }
-        /// Clones a reference type, replacing any parameters it may have with a clone of the provided list
-        template< typename GenericInstType >
-        GenericInstType *cloneWithParams( GenericInstType *refType, const std::list< Expression* >& params ) {
-                GenericInstType *clone = refType->clone();
-                clone->get_parameters().clear();
-                cloneAll( params, clone->get_parameters() );
-                return clone;
+        }
-        /// Creates a new type decl that's the same as src, but renamed and with only the ?=? assertion (for complete types only)
-        TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) {
-                TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() );
-                if ( src->get_kind() == TypeDecl::Any ) {
-                        // just include assignment operator assertion
-                        TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst );
-                        FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false );
-                        assignFunctionType->get_returnVals().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) );
-                        FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false );
-                        dst->get_assertions().push_back( assignAssert );
+                }
-                return dst;
+        }
-        Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
-                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-                // Make function polymorphic in same parameters as generic struct, if applicable
-                bool isGeneric = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
-                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
-                std::list< Expression* > structParams;  // List of matching parameters to put on types
-                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
-                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
-                        isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
-                        assignType->get_forall().push_back( typeParam );
-                        TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam );
-                        genericSubs.add( (*param)->get_name(), newParamType );
-                        structParams.push_back( new TypeExpr( newParamType ) );
+                }
-                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
-                assignType->get_returnVals().push_back( returnVal );
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
-                assignType->get_parameters().push_back( srcParam );
-                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
-                // because each unit generates copies of the default routines for each aggregate.
-                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
-                assignDecl->fixUniqueId();
-                for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
-                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
-                                // query the type qualifiers of this field and skip assigning it if it is marked const.
-                                // If it is an array type, we need to strip off the array layers to find its qualifiers.
-                                Type * type = dwt->get_type();
-                                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-                                        type = at->get_base();
+                                }
-                                if ( type->get_qualifiers().isConst ) {
-                                        // don't assign const members
-                                        continue;
+                                }
-                                if ( isGeneric ) {
-                                        // rewrite member type in terms of the type variables on this operator
-                                        DeclarationWithType *fixedMember = dwt->clone();
-                                        genericSubs.apply( fixedMember );
-                                        // assign to both destination and return value
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
-                                } else {
-                                        // assign to destination
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
-                                } // if
-                        } // if
-                } // for
-                if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-                return assignDecl;
+        }
-        Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
-                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-                // Make function polymorphic in same parameters as generic union, if applicable
-                bool isGeneric = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
-                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
-                std::list< Expression* > unionParams;  // List of matching parameters to put on types
-                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
-                        isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
-                        assignType->get_forall().push_back( typeParam );
-                        unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
+                }
-                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
-                assignType->get_returnVals().push_back( returnVal );
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, unionParams ) ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
-                assignType->get_parameters().push_back( srcParam );
-                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
-                // because each unit generates copies of the default routines for each aggregate.
-                FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
-                assignDecl->fixUniqueId();
-                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
-                if ( isGeneric ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
-                if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-                return assignDecl;
+        }
-        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
-                if ( ! enumDecl->get_members().empty() ) {
-                        EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
-                        // enumInst->set_baseEnum( enumDecl );
-                        // declsToAdd.push_back(
-                        makeEnumAssignment( enumDecl, enumInst, functionNesting, declsToAdd );
+                }
+        }
-        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
-                if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
-                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
-                        structInst.set_baseStruct( structDecl );
-                        declsToAdd.push_back( makeStructAssignment( structDecl, &structInst, functionNesting ) );
-                        structsDone.insert( structDecl->get_name() );
-                } // if
+        }
-        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
-                if ( ! unionDecl->get_members().empty() ) {
-                        UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
-                        unionInst.set_baseUnion( unionDecl );
-                        declsToAdd.push_back( makeUnionAssignment( unionDecl, &unionInst, functionNesting ) );
-                } // if
+        }
-        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
-                CompoundStmt *stmts = 0;
-                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
-                typeInst->set_baseType( typeDecl );
-                ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
-                ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
-                if ( typeDecl->get_base() ) {
-                        stmts = new CompoundStmt( std::list< Label >() );
-                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                        assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
-                        assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
-                        stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
-                } // if
-                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
-                type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
-                type->get_parameters().push_back( dst );
-                type->get_parameters().push_back( src );
-                FunctionDecl *func = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false, false );
-                declsToAdd.push_back( func );
+        }
-        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
-                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
-                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
-                } // for
-                declsToAdd.clear();
+        }
-        void AutogenerateRoutines::visit( FunctionType *) {
-                // ensure that we don't add assignment ops for types defined as part of the function
+        }
-        void AutogenerateRoutines::visit( PointerType *) {
-                // ensure that we don't add assignment ops for types defined as part of the pointer
+        }
-        void AutogenerateRoutines::visit( TraitDecl *) {
-                // ensure that we don't add assignment ops for types defined as part of the context
+        }
-        template< typename StmtClass >
-        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
-                std::set< std::string > oldStructs = structsDone;
-                addVisit( stmt, *this );
-                structsDone = oldStructs;
+        }
-        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
-                maybeAccept( functionDecl->get_functionType(), *this );
-                acceptAll( functionDecl->get_oldDecls(), *this );
-                functionNesting += 1;
-                maybeAccept( functionDecl->get_statements(), *this );
-                functionNesting -= 1;
+        }
-        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
-                visitStatement( compoundStmt );
+        }
-        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
-                visitStatement( switchStmt );
+        }
-        void AutogenerateRoutines::visit( ChooseStmt *switchStmt ) {
-                visitStatement( switchStmt );
+        }
-        // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
-        //      visitStatement( caseStmt );
-        // }
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
                 ReturnChecker checker;
 …
                 return aggDecl;
+        }
         template<typename AggDecl>
         void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
 …
+        }
+        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
+                VerifyCtorDtor verifier;
+                acceptAll( translationUnit, verifier );
+        }
+        void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
+                FunctionType * funcType = funcDecl->get_functionType();
+                std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
+                std::list< DeclarationWithType * > &params = funcType->get_parameters();
+                if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
+                        if ( params.size() == 0 ) {
+                                throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
+                        }
+                        if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
+                                throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
+                        }
+                        if ( returnVals.size() != 0 ) {
+                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
+                }
+                Visitor::visit( funcDecl );
+                // original idea: modify signature of ctor/dtors and insert appropriate return statements
+                // to cause desired behaviour
+                // new idea: add comma exprs to every ctor call to produce first parameter.
+                // this requires some memoization of the first parameter, because it can be a
+                // complicated expression with side effects (see: malloc). idea: add temporary variable
+                // that is assigned address of constructed object in ctor argument position and
+                // return the temporary. It should also be done after all implicit ctors are
+                // added, so not in this pass!
+        }
         DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
                 storageclass = objectDecl->get_storageClass();

src/SymTab/module.mk

-              rbb8ea30
+              rd668182
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
        SymTab/FixFunction.cc \
        SymTab/ImplementationType.cc \
+       SymTab/TypeEquality.cc
+       SymTab/TypeEquality.cc \
+       SymTab/Autogen.cc

src/SynTree/CommaExpr.cc

rbb8ea30	rd668182
10	10	// Created On : Mon May 18 07:44:20 2015
11	11	// Last Modified By : Rob Schluntz
12		// Last Modified On : Mon May 02 15:1~~1:29~~ 2016
	12	// Last Modified On : Mon May 02 15:19:44 2016
13	13	// Update Count : 1
14	14	//

src/SynTree/CompoundStmt.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Mon May 02 15:10:47 2016
+// Last Modified On : Mon May 02 15:19:17 2016
 // Update Count     : 3
 //
 …
 #include <algorithm>
 #include <functional>
+#include "Expression.h"
+#include "Declaration.h"
 using std::string;
 using std::endl;
+class VarExprReplacer : public Visitor {
+public:
+  typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+private:
+  const DeclMap & declMap;
+public:
+  VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+  // replace variable with new node from decl map
+  virtual void visit( VariableExpr * varExpr ) {
+    if ( declMap.count( varExpr->get_var() ) ) {
+      varExpr->set_var( declMap.at( varExpr->get_var() ) );
+    }
+  }
+};
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
 …
 CompoundStmt::CompoundStmt( const CompoundStmt &other ) : Statement( other ) {
         cloneAll( other.kids, kids );
+  // when cloning a compound statement, we may end up cloning declarations which
+  // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
+  // does a shallow copy, so the VariableExpr will end up pointing to the original
+  // declaration. If the original declaration is deleted, e.g. because the original
+  // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
+  // find all DeclarationWithType nodes (since a VariableExpr must point to a
+  // DeclarationWithType) in the original CompoundStmt and map them to the cloned
+  // node in the new CompoundStmt ('this'), then replace the Declarations referred to
+  // by each VariableExpr according to the constructed map. Note that only the declarations
+  // in the current level are collected into the map, because child CompoundStmts will
+  // recursively execute this routine. There may be more efficient ways of doing
+  // this.
+  VarExprReplacer::DeclMap declMap;
+  std::list< Statement * >::const_iterator origit = other.kids.begin();
+  for ( Statement * s : kids ) {
+    assert( origit != other.kids.end() );
+    if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
+      DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( *origit );
+      assert( origDeclStmt );
+      if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
+        DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+        assert( origdwt );
+        declMap[ origdwt ] = dwt;
+      }
+    }
+  }
+  if ( ! declMap.empty() ) {
+    VarExprReplacer replacer( declMap );
+    accept( replacer );
+  }
+}

src/SynTree/Constant.cc

rbb8ea30	rd668182
30	30	Constant::~Constant() { delete type; }
31	31
32		Constant Constant::from( int i ) {
	32	Constant Constant::from_int( int i ) {
33	33	return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) );
34	34	}
35	35
36		Constant Constant::from( unsigned long i ) {
	36	Constant Constant::from_ulong( unsigned long i ) {
37	37	return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) );
38	38	}
39	39
40		Constant Constant::from( double d ) {
	40	Constant Constant::from_double( double d ) {
41	41	return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) );
42	42	}

src/SynTree/Constant.h

-              rbb8ea30
+              rd668182
         /// generates an integer constant of the given int
         static Constant from( int i );
+        static Constant from_int( int i );
         /// generates an integer constant of the given unsigned long int
         static Constant from( unsigned long i );
+        static Constant from_ulong( unsigned long i );
         /// generates a floating point constant of the given double
         static Constant from( double d );
+        static Constant from_double( double d );
         virtual Constant *clone() const;

src/SynTree/Declaration.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Declaration.h --
+// Declaration.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:28:11 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 06 16:26:12 2016
 // Update Count     : 33
 //
 …
 #include "Parser/LinkageSpec.h"
 #include "Parser/ParseNode.h"
+#include <string>
 class Declaration {
 …
         void set_mangleName( std::string newValue ) { mangleName = newValue; }
+        std::string get_scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
+        int get_scopeLevel() const { return scopeLevel; }
+        void set_scopeLevel( int newValue ) { scopeLevel = newValue; }
         virtual DeclarationWithType *clone() const = 0;
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
 …
         // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
         std::string mangleName;
+        // need to remember the scope level at which the variable was declared, so that
+        // shadowed identifiers can be accessed
+        int scopeLevel = 0;
 };
 …
         typedef DeclarationWithType Parent;
   public:
+        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn );
+        // temporary - merge this into general GCC attributes
+        struct Attribute {
+                enum Type {
+                        NoAttribute, Constructor, Destructor,
+                } type;
+                enum Priority {
+                        // priorities 0-100 are reserved by gcc, so it's okay to use 100 an exceptional case
+                        Default = 100, High,
+                } priority;
+                Attribute(Type t = NoAttribute, Priority p = Default) : type(t), priority(p) {};
+        };
+        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, Attribute attribute = Attribute() );
         FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();
 …
         std::list< std::string >& get_oldIdents() { return oldIdents; }
         std::list< Declaration* >& get_oldDecls() { return oldDecls; }
+        Attribute get_attribute() const { return attribute; }
+        void set_attribute( Attribute newValue ) { attribute = newValue; }
         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
 …
         std::list< std::string > oldIdents;
         std::list< Declaration* > oldDecls;
+        Attribute attribute;
 };

src/SynTree/DeclarationWithType.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // DeclarationWithType.cc --
+// DeclarationWithType.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 13 08:08:07 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon Apr 11 15:35:27 2016
 // Update Count     : 3
 //
 …
 DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
                 : Declaration( other ), mangleName( other.mangleName ) {
+                : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ) {
+}

src/SynTree/Expression.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri May 13 13:19:09 2016
+// Last Modified On : Fri May 13 13:23:11 2016
 // Update Count     : 40
 //
 …
 VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
+        assert( var );
+        assert( var->get_type() );
         add_result( var->get_type()->clone() );
         for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
 …
+}
+ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
+        assert( callExpr );
+        cloneAll( callExpr->get_results(), results );
+}
+ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
+        cloneAll( other.tempDecls, tempDecls );
+        cloneAll( other.returnDecls, returnDecls );
+        cloneAll( other.dtors, dtors );
+}
+ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() {
+        delete callExpr;
+        deleteAll( tempDecls );
+        deleteAll( returnDecls );
+        deleteAll( dtors );
+}
+void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) <<  "Implicit Copy Constructor Expression: " << std::endl;
+        assert( callExpr );
+        callExpr->print( os, indent + 2 );
+        os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
+        printAll(tempDecls, os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "with return temporaries:" << std::endl;
+        printAll(returnDecls, os, indent+2);
+        Expression::print( os, indent );
+}
 UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}

src/SynTree/Expression.h

-              rbb8ea30
+              rd668182
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  8 17:18:06 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:06:49 2016
 // Update Count     : 21
 //
 …
 #include "Mutator.h"
 #include "Constant.h"
+#include "Common/UniqueName.h"
 /// Expression is the root type for all expressions
 …
 };
+/// ImplicitCopyCtorExpr represents the application of a function to a set of parameters,
+/// along with a set of copy constructor calls, one for each argument.
+class ImplicitCopyCtorExpr : public Expression {
+public:
+        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
+        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
+        virtual ~ImplicitCopyCtorExpr();
+        ApplicationExpr *get_callExpr() const { return callExpr; }
+        void set_callExpr( ApplicationExpr *newValue ) { callExpr = newValue; }
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; }
+        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; }
+        std::list< Expression * > & get_dtors() { return dtors; }
+        void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; }
+        virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        ApplicationExpr * callExpr;
+        std::list< ObjectDecl * > tempDecls;
+        std::list< ObjectDecl * > returnDecls;
+        std::list< Expression * > dtors;
+};
 /// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {

src/SynTree/FunctionDecl.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Tue May 03 15:37:43 2016
+// Last Modified On : Fri May 06 15:59:48 2016
 // Update Count     : 19
 //
 …
 #include "Common/utility.h"
 FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn )
                 : Parent( name, sc, linkage ), type( type ), statements( statements ) {
+FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, Attribute attribute )
+                : Parent( name, sc, linkage ), type( type ), statements( statements ), attribute( attribute ) {
         set_isInline( isInline );
         set_isNoreturn( isNoreturn );
 …
 FunctionDecl::FunctionDecl( const FunctionDecl &other )
         : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
+        : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ), attribute( other.attribute ) {
+}
 …
                 os << "_Noreturn ";
         } // if
+        switch ( attribute.type ) {
+                case Attribute::Constructor:
+                        os << "Global Constructor ";
+                        break;
+                case Attribute::Destructor:
+                        os << "Global Destructor ";
+                        break;
+                default:
+                        break;
+        }
+        if ( attribute.priority != Attribute::Default ) {
+                os << "with priority " << attribute.priority << " ";
+        }
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
 …
                 os << "_Noreturn ";
         } // if
+        switch ( attribute.type ) {
+                case Attribute::Constructor:
+                        os << " Global Constructor ";
+                        break;
+                case Attribute::Destructor:
+                        os << " Global Destructor ";
+                        break;
+                default:
+                        break;
+        }
+        if ( attribute.priority != Attribute::Default ) {
+                os << "with priority " << attribute.priority << " ";
+        }
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
                 os << DeclarationNode::storageName[ get_storageClass() ] << ' ';

src/SynTree/Initializer.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri May 13 13:19:30 2016
+// Last Modified On : Fri May 13 13:23:03 2016
 // Update Count     : 28
 //
 …
 #include "Initializer.h"
 #include "Expression.h"
+#include "Statement.h"
 #include "Common/utility.h"
 Initializer::Initializer() {}
+Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
 Initializer::~Initializer() {}
 …
 void Initializer::print( std::ostream &os, int indent ) {}
 SingleInit::SingleInit( Expression *v, std::list< Expression *> &_designators ) : value ( v ), designators( _designators ) {
+SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) {
+}
 SingleInit::SingleInit( const SingleInit &other ) : value ( other.value ) {
+SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) {
         cloneAll(other.designators, designators );
+}
 …
+}
 ListInit::ListInit( std::list<Initializer*> &_initializers, std::list<Expression *> &_designators )
         : initializers( _initializers ), designators( _designators ) {
+ListInit::ListInit( const std::list<Initializer*> &_initializers, const std::list<Expression *> &_designators, bool maybeConstructed )
+        : Initializer( maybeConstructed), initializers( _initializers ), designators( _designators ) {
+}
 …
                 (*i)->print( os, indent + 2 );
+}
+ConstructorInit::ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init ) : Initializer( true ), ctor( ctor ), dtor( dtor ), init( init ) {}
+ConstructorInit::~ConstructorInit() {
+        delete ctor;
+        delete init;
+}
+ConstructorInit *ConstructorInit::clone() const {
+        return new ConstructorInit( *this );
+}
+void ConstructorInit::print( std::ostream &os, int indent ) {
+        os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
+        if ( ctor ) {
+                os << std::string(indent+2, ' ');
+                os << "initially constructed with ";
+                ctor->print( os, indent+4 );
+        } // if
+        if ( dtor ) {
+                os << std::string(indent+2, ' ');
+                os << "destructed with ";
+                dtor->print( os, indent+4 );
+        }
+        if ( init ) {
+                os << std::string(indent+2, ' ');
+                os << "with fallback C-style initializer: ";
+                init->print( os, indent+4 );
+        }
+}
+std::ostream & operator<<( std::ostream & out, Initializer * init ) {
+        init->print( out );
+        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Initializer.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Initializer.h --
+// Initializer.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May 18 09:03:48 2015
 // Update Count     : 1
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 12 13:49:13 2016
+// Update Count     : 19
 //
 …
   public:
         //      Initializer( std::string _name = std::string(""), int _pos = 0 );
         Initializer( );
+        Initializer( bool maybeConstructed );
         virtual ~Initializer();
 …
+        }
+        bool get_maybeConstructed() { return maybeConstructed; }
         virtual Initializer *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
 …
         //      std::string name;
         //      int pos;
+        bool maybeConstructed;
 };
 …
 class SingleInit : public Initializer {
   public:
         SingleInit( Expression *value, std::list< Expression *> &designators = *(new std::list<Expression *>()) );
+        SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
         SingleInit( const SingleInit &other );
         virtual ~SingleInit();
         Expression *get_value() { return value; }
         void set_value( Expression *newValue ) { value = newValue; }
 …
 class ListInit : public Initializer {
   public:
         ListInit( std::list<Initializer*> &,
                           std::list<Expression *> &designators = *(new std::list<Expression *>()) );
+        ListInit( const std::list<Initializer*> &initializers,
+                          const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
         virtual ~ListInit();
 …
 };
+// ConstructorInit represents an initializer that is either a constructor expression or
+// a C-style initializer.
+class ConstructorInit : public Initializer {
+  public:
+        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
+        virtual ~ConstructorInit();
+        void set_ctor( Statement * newValue ) { ctor = newValue; }
+        Statement * get_ctor() const { return ctor; }
+        void set_dtor( Statement * newValue ) { dtor = newValue; }
+        Statement * get_dtor() const { return dtor; }
+        void set_init( Initializer * newValue ) { init = newValue; }
+        Initializer * get_init() const { return init; }
+        virtual ConstructorInit *clone() const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Statement * ctor;
+        Statement * dtor;
+        // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
+        // if an appropriate constructor definition is not found by the resolver
+        Initializer * init;
+};
+std::ostream & operator<<( std::ostream & out, Initializer * init );
 #endif // INITIALIZER_H

src/SynTree/Mutator.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Mutator.cc --
+// Mutator.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  1 18:05:16 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:07:29 2016
 // Update Count     : 16
 //
 …
+}
+Expression* Mutator::mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+        impCpCtorExpr->set_callExpr( maybeMutate( impCpCtorExpr->get_callExpr(), *this ) );
+        mutateAll( impCpCtorExpr->get_tempDecls(), *this );
+        mutateAll( impCpCtorExpr->get_returnDecls(), *this );
+        return impCpCtorExpr;
+}
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
         mutateAll( valofExpr->get_results(), *this );
 …
+}
+Initializer *Mutator::mutate( ConstructorInit *ctorInit ) {
+        ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
+        ctorInit->set_init( maybeMutate( ctorInit->get_init(), *this ) );
+        return ctorInit;
+}
 Subrange *Mutator::mutate( Subrange *subrange ) {
         return subrange;

src/SynTree/Mutator.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Mutator.h --
+// Mutator.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  1 17:26:56 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:32:00 2016
 // Update Count     : 10
 //
 …
         virtual Expression* mutate( MemberExpr *memberExpr );
         virtual Expression* mutate( VariableExpr *variableExpr );
         virtual Expression* mutate( ConstantExpr *constantExpr );
+        virtual Expression* mutate( ConstantExpr *constantExpr );
         virtual Expression* mutate( SizeofExpr *sizeofExpr );
         virtual Expression* mutate( AlignofExpr *alignofExpr );
 …
         virtual Expression* mutate( TypeExpr *typeExpr );
         virtual Expression* mutate( AsmExpr *asmExpr );
+        virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
         virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
 …
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );
+        virtual Initializer* mutate( ConstructorInit *ctorInit );
         virtual Subrange *mutate( Subrange *subrange );

src/SynTree/ObjectDecl.cc

-              rbb8ea30
+              rd668182
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri May 13 13:20:17 2016
+// Last Modified On : Fri May 13 13:23:32 2016
 // Update Count     : 30
 //
 …
 #include "Expression.h"
 #include "Common/utility.h"
+#include "Statement.h"
 ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init, bool isInline, bool isNoreturn )
 …
                 os << " with initializer ";
                 init->print( os, indent );
+                os << std::endl << std::string(indent, ' ');
+                os << "maybeConstructed? " << init->get_maybeConstructed();
         } // if

src/SynTree/SynTree.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // SynTree.h --
+// SynTree.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  1 16:47:44 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:31:36 2016
 // Update Count     : 5
 //
 …
 class TypeExpr;
 class AsmExpr;
+class ImplicitCopyCtorExpr;
 class UntypedValofExpr;
 class CompoundLiteralExpr;
 …
 class SingleInit;
 class ListInit;
+class ConstructorInit;
 class Subrange;

src/SynTree/TypeSubstitution.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // TypeSubstitution.cc --
+// TypeSubstitution.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:29:15 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 26 11:15:29 2016
 // Update Count     : 3
 //
 …
         BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
         if ( bound != boundVars.end() ) return inst;
         TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
         if ( i == typeEnv.end() ) {
 …
+}
+std::ostream & operator<<( std::ostream & out, const TypeSubstitution & sub ) {
+        sub.print( out );
+        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/TypeSubstitution.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // TypeSubstitution.h --
+// TypeSubstitution.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:33:19 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Apr 29 15:00:20 2016
 // Update Count     : 2
 //
 …
         TypeSubstitution( const TypeSubstitution &other );
         virtual ~TypeSubstitution();
         TypeSubstitution &operator=( const TypeSubstitution &other );
         template< typename SynTreeClass > int apply( SynTreeClass *&input );
         template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
         void add( std::string formalType, Type *actualType );
         void add( const TypeSubstitution &other );
 …
         Type *lookup( std::string formalType ) const;
         bool empty() const;
         template< typename FormalIterator, typename ActualIterator >
         void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+        /// this function is unused...
         template< typename TypeInstListIterator >
         void extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result );
         void normalize();
 …
         /// Records type variable bindings from forall-statements and instantiations of generic types
         template< typename TypeClass > Type *handleAggregateType( TypeClass *type );
         virtual Type* mutate(VoidType *basicType);
         virtual Type* mutate(BasicType *basicType);
 …
         virtual Type* mutate(TupleType *tupleType);
         virtual Type* mutate(VarArgsType *varArgsType);
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
 …
         return subCount;
+}
 template< typename SynTreeClass >
 int TypeSubstitution::applyFree( SynTreeClass *&input ) {
 …
         return subCount;
+}
 template< typename TypeInstListIterator >
 void TypeSubstitution::extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result ) {
+        // xxx - this function doesn't extract varEnv - is this intentional?
         while ( begin != end ) {
                 TypeEnvType::iterator cur = typeEnv.find( (*begin++)->get_name() );
 …
+}
+std::ostream & operator<<( std::ostream & out, const TypeSubstitution & sub );
 #endif // TYPESUBSTITUTION_H

src/SynTree/Visitor.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Visitor.cc --
+// Visitor.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  1 18:05:13 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:07:40 2016
 // Update Count     : 18
 //
 …
+}
+void Visitor::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+        maybeAccept( impCpCtorExpr->get_callExpr(), *this );
+        acceptAll( impCpCtorExpr->get_tempDecls(), *this );
+        acceptAll( impCpCtorExpr->get_returnDecls(), *this );
+}
 void Visitor::visit( UntypedValofExpr *valofExpr ) {
         acceptAll( valofExpr->get_results(), *this );
 …
+}
+void Visitor::visit( ConstructorInit *ctorInit ) {
+        maybeAccept( ctorInit->get_ctor(), *this );
+        maybeAccept( ctorInit->get_init(), *this );
+}
 void Visitor::visit( Subrange *subrange ) {}

src/SynTree/Visitor.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // Visitor.h --
+// Visitor.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  1 17:26:55 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:30:58 2016
 // Update Count     : 7
 //
 …
         virtual void visit( MemberExpr *memberExpr );
         virtual void visit( VariableExpr *variableExpr );
         virtual void visit( ConstantExpr *constantExpr );
+        virtual void visit( ConstantExpr *constantExpr );
         virtual void visit( SizeofExpr *sizeofExpr );
         virtual void visit( AlignofExpr *alignofExpr );
 …
         virtual void visit( TypeExpr *typeExpr );
         virtual void visit( AsmExpr *asmExpr );
+        virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
         virtual void visit( CompoundLiteralExpr *compLitExpr );
 …
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );
+        virtual void visit( ConstructorInit *ctorInit );
         virtual void visit( Subrange *subrange );

src/driver/cc1.cc

-              rbb8ea30
+              rd668182
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 25 16:05:15 2016
 // Update Count     : 56
+// Last Modified On : Thu May  5 16:04:30 2016
+// Update Count     : 77
 //
 …
         const char *args[argc + 100];                                           // leave space for 100 additional cpp command line values
         int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
         const char *uargs[20];                                                          // leave space for 20 additional cfa-cpp command line values
         int nuargs = 1;                                                                         // 0 => command name
+        const char *cargs[20];                                                          // leave space for 20 additional cfa-cpp command line values
+        int ncargs = 1;                                                                         // 0 => command name
         signal( SIGINT,  sigTermHandler );
         signal( SIGTERM, sigTermHandler );
+#ifdef __DEBUG_H__
+        cerr << "Stage1" << endl;
+#endif // __DEBUG_H__
         // process all the arguments
 …
                                 CFA_flag = true;
                         } else if ( prefix( arg, D__CFA_FLAGPREFIX__ ) ) {
                                 uargs[nuargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
                                 nuargs += 1;
+                                cargs[ncargs] = ( *new string( arg.substr( D__CFA_FLAGPREFIX__.size() ) ) ).c_str();
+                                ncargs += 1;
                         } else if ( arg == "-D" && prefix( argv[i + 1], D__CFA_FLAGPREFIX__.substr(2) ) ) {
                                 uargs[nuargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
                                 nuargs += 1;
+                                cargs[ncargs] = ( *new string( string( argv[i + 1] ).substr( D__CFA_FLAGPREFIX__.size() - 2 ) ) ).c_str();
+                                ncargs += 1;
                                 i += 1;                                                                 // and the argument
                         } else if ( prefix( arg, D__GCC_BPREFIX__ ) ) {
 …
         if ( fork() == 0 ) {                                                            // child runs CFA
+                uargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
+                uargs[nuargs] = tmpname;
+                nuargs += 1;
+                cargs[0] = ( *new string( bprefix + "/cfa-cpp" ) ).c_str();
+                // Source file-name used to generate routine names containing global initializations for TU.
+                cargs[ncargs] = ( *new string( "-F" ) ).c_str();
+                ncargs += 1;
+                cargs[ncargs] = ( *new string( string( cpp_in ) ) ).c_str();
+                ncargs += 1;
+                cargs[ncargs] = tmpname;
+                ncargs += 1;
                 if ( o_name != NULL ) {
                         uargs[nuargs] = o_name;
                         nuargs += 1;
+                        cargs[ncargs] = o_name;
+                        ncargs += 1;
                 } else if ( ! CFA_flag ) {                                              // run cfa-cpp ?
                         uargs[nuargs] = cpp_out;
                         nuargs += 1;
+                        cargs[ncargs] = cpp_out;
+                        ncargs += 1;
                 } // if
                 uargs[nuargs] = NULL;                                                   // terminate argument list
 #ifdef __DEBUG_H__
                 cerr << "cfa-cpp nuargs: " << o_name << " " << CFA_flag << " " << nuargs << endl;
                 for ( i = 0; uargs[i] != NULL; i += 1 ) {
                         cerr << uargs[i] << " ";
+                cargs[ncargs] = NULL;                                                   // terminate argument list
+#ifdef __DEBUG_H__
+                cerr << "cfa-cpp ncargs: " << o_name << " " << CFA_flag << " " << ncargs << endl;
+                for ( i = 0; cargs[i] != NULL; i += 1 ) {
+                        cerr << cargs[i] << " ";
                 } // for
                 cerr << endl;
 #endif // __DEBUG_H__
                 execvp( uargs[0], (char * const *)uargs );              // should not return
+                execvp( cargs[0], (char * const *)cargs );              // should not return
                 perror( "CFA Translator error: cpp level, execvp" );
                 exit( EXIT_FAILURE );
 …
         const char *args[argc + 100];                                           // leave space for 100 additional cfa command line values
         int nargs = 1;                                                                          // number of arguments in args list; 0 => command name
+#ifdef __DEBUG_H__
+        cerr << "Stage2" << endl;
+#endif // __DEBUG_H__
         // process all the arguments
 …
         if ( arg == "-E" ) {
-#ifdef __DEBUG_H__
-                cerr << "Stage1" << endl;
-#endif // __DEBUG_H__
                 Stage1( argc, argv );
         } else if ( arg == "-fpreprocessed" ) {
-#ifdef __DEBUG_H__
-                cerr << "Stage2" << endl;
-#endif // __DEBUG_H__
                 Stage2( argc, argv );
         } else {

src/examples/abstype.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:10:01 2015
 // Update Count     : 4
+// Last Modified On : Wed Apr  6 22:16:08 2016
+// Update Count     : 8
 //
 type T | { T x( T ); };
+otype T | { T x( T ); };
 T y( T t ) {
 …
+}
 forall(type T) lvalue T *?( T* );
 int ?++( int *);
 int ?=?( int*, int );
 forall(dtype DT) DT* ?=?( DT **, DT* );
+forall( otype T ) lvalue T *?( T* );
+int ?++( int * );
+int ?=?( int *, int );
+forall( dtype DT ) DT * ?=?( DT **, DT* );
 type U = int*;
+otype U = int *;
 U x( U u ) {

src/examples/alloc.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 11:43:23 2016
 // Update Count     : 40
+// Last Modified On : Fri Mar 11 17:42:08 2016
+// Update Count     : 59
 //
+forall( otype T ) T * malloc( char fill );
+forall( dtype T ) T *?=?( T **, void * );
+void *malloc( unsigned long int );
+#if 0
 #include <fstream>
 #include <stdlib>
 …
 int * bar( int * p, int c ) { return p; }
 int * baz( int * p, int c ) { return p; }
+#endif
 int main( void ) {
+#if 0
     size_t size = 10;
     int * p;
     struct S { int x; double y; } * s;
+#endif
+#if 0
     p = malloc( sizeof(*p) );                                                   // C malloc, type unsafe
         printf( "here1\n" );
 …
         printf( "here2\n" );
     free( p );
+    p = malloc( (char)'\0' );                                                                   // CFA malloc, type safe
+#endif
+//    int * p;
+//    p = malloc( (char)'\0' );                                                                 // CFA malloc, type safe
+    (int *)malloc( (char)'\0' );                                                                        // CFA malloc, type safe
+    (void *)malloc( (char)'\0' );                                                                       // CFA malloc, type safe
+#if 0
         printf( "here3\n" );
     p = malloc( p, 1000 );                                                              // CFA remalloc, type safe
 …
         printf( "here9\n" );
     free( p );
+#if 0
     float * fp = malloc() + 1;
     fprintf( stderr, "%p %p\n", fp, fp - 1 );

src/examples/array.c

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // array.c --
+// array.c --
 //
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 18:13:52 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:21:52 2016
 // Update Count     : 3
 //
 …
 // The first element is always at index 0.
 forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type * begin( array_type array ) {
+elt_type * begin( array_type * array ) {
         return &array[ 0 ];
+}
 …
 // The end iterator should point one past the last element.
 forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type * end( array_type array ) {
+elt_type * end( array_type * array ) {
         return &array[ last( array ) ] + 1;
+}

src/examples/array.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // array.h --
+// array.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 18:13:35 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:04 2016
 // Update Count     : 5
 //
 …
 // A bounded array is an array that carries its maximum index with it.
 trait bounded_array( otype array_type, otype elt_type | array( array_type, elt_type ) ) {
         int last( array_type );
+trait bounded_array( otype array_type, otype elt_type | array( array_type *, elt_type ) ) {
+        int last( array_type * );
 };
 …
 // return iterators corresponding to the first element and the one-past-the-end element, STL-style.
 forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type *begin( array_type );
+elt_type * begin( array_type * array );
+// The end iterator should point one past the last element.
 forall( otype array_type, otype elt_type | bounded_array( array_type, elt_type ) )
 elt_type *end( array_type );
+elt_type * end( array_type * array );
 #endif // ARRAY_H

src/examples/fstream_test.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Mar  6 20:58:29 2016
 // Update Count     : 54
+// Last Modified On : Mon May  2 15:25:54 2016
+// Update Count     : 61
 //

src/examples/includes.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 23:28:02 2016
 // Update Count     : 328
+// Last Modified On : Wed Apr 13 22:30:02 2016
+// Update Count     : 370
 //
 …
 #if 1
 #define _GNU_SOURCE
 #include <aio.h>
 #include <a.out.h>
 #include <aliases.h>
 #include <alloca.h>
 #include <ansidecl.h>
 #include <ar.h>
 #include <argp.h>
+//#include <aio.h>
+//#include <a.out.h>
+//#include <aliases.h>
+//#include <alloca.h>
+//#include <ansidecl.h>
+//#include <ar.h>
+//#include <argp.h>
 #include <argz.h>
 #include <assert.h>
+//#include <assert.h>
 #include <bfd.h>
+#if 0
 #include <bfdlink.h>
 #include <byteswap.h>
 …
 #include <err.h>
 #include <errno.h>
-#if 0
 #include <error.h>
-#endif
 #include <eti.h>
 #include <evdns.h>
 #include <event.h>
 #include <evhttp.h>
+#endif
 #if 0
 #include <evrpc.h>
 …
 //#define _GNU_SOURCE
+#include <error.h>
+#include <bfd.h>
+//#include <error.h>
 #endif // 0

src/examples/io.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 13 23:03:14 2016
 // Update Count     : 22
+// Last Modified On : Sat Apr 30 08:34:13 2016
+// Update Count     : 27
 //
 …
                  | sepDisable | fc | dc | ldc | sepEnable | endl                // complex without separator
                  | sepOn | s1 | sepOff | s2 | endl                                              // local separator removal
                  | s1 | "" | s2 | endl;                                                                 // C string withou separator
+                 | s1 | "" | s2 | endl;                                                                 // C string without separator
         sout | endl;
 …
                 | "£" | 27
                 | "¥" | 27
+                | "¡" | 27
                 | "¿" | 27
                 | "«" | 27

src/examples/rational.c

-              rbb8ea30
+              rd668182
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  8 11:27:48 2016
 // Update Count     : 21
+// Last Modified On : Wed May  4 14:19:36 2016
+// Update Count     : 24
 //
 …
 int main() {
-        Rational a, b, c;
         sout | "constructor" | endl;
+        a = rational( 3 );
+        b = rational( 4 );
+        c = rational();
+        Rational a = { 3 }, b = { 4 }, c;
         sout | a | b | c | endl;
         a = rational( 4, 8 );
         b = rational( 5, 7 );
+        a = (Rational){ 4, 8 };
+        b = (Rational){ 5, 7 };
         sout | a | b | endl;
         a = rational( -2, -3 );
         b = rational( 3, -2 );
+        a = (Rational){ -2, -3 };
+        b = (Rational){ 3, -2 };
         sout | a | b | endl;
         a = rational( -2, 3 );
         b = rational( 3, 2 );
+        a = (Rational){ -2, 3 };
+        b = (Rational){ 3, 2 };
         sout | a | b | endl;
         sout | "logical" | endl;
         a = rational( -2 );
         b = rational( -3, 2 );
+        a = (Rational){ -2 };
+        b = (Rational){ -3, 2 };
         sout | a | b | endl;
         sout | a == 1 | endl;
 …
         sout | "conversion" | endl;
         a = rational( 3, 4 );
+        a = (Rational){ 3, 4 };
         sout | widen( a ) | endl;
         a = rational( 1, 7 );
+        a = (Rational){ 1, 7 };
         sout | widen( a ) | endl;
         a = rational( 355, 113 );
+        a = (Rational){ 355, 113 };
         sout | widen( a ) | endl;
         sout | narrow( 0.75, 4 ) | endl;
 …
         sout | narrow( 3.14159265358979, 256 ) | endl;
+        Rational x, y;
+        x = rational( 1, 2 );
+        y = rational( 2 );
+        Rational x = { 1, 2 }, y = { 2 };
         sout | x - y | endl;
         sout | x > y | endl;
 …
         sout | y | denominator( y, -2 ) | y | endl;
+        Rational z;
+        z = rational( 0, 5 );
+        Rational z = { 0, 5 };
         sout | z | endl;
         sout | x | numerator( x, 0 ) | x | endl;
         x = rational( 1, MAX ) + rational( 1, MAX );
+        x = (Rational){ 1, MAX } + (Rational){ 1, MAX };
         sout | x | endl;
         x = rational( 3, MAX ) + rational( 2, MAX );
+        x = (Rational){ 3, MAX } + (Rational){ 2, MAX };
         sout | x | endl;

src/examples/sum.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Mar  4 15:06:47 2016
 // Update Count     : 196
+// Last Modified On : Mon May  2 15:07:57 2016
+// Update Count     : 198
 //
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | (int)sum( size, a ) | "" | ", check" | (int)s | endl;
+                 | (int)sum( size, a ) | ", check" | (int)s | endl;
         int s = 0, a[size], v = low;
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, (int *)a ) | "" | ", check" | (int)s | endl;
+                 | sum( size, (int *)a ) | ", check" | (int)s | endl;
         float s = 0.0, a[size], v = low / 10.0;
 …
         } // for
         sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is"
                  | sum( size, (float *)a ) | "" | ", check" | (float)s | endl;
+                 | sum( size, (float *)a ) | ", check" | (float)s | endl;
         double s = 0, a[size], v = low / 10.0;
 …
         } // for
         sout | "sum from" | low / 10.0 | "to" | High / 10.0 | "is"
                  | sum( size, (double *)a ) | "" | ", check" | (double)s | endl;
+                 | sum( size, (double *)a ) | ", check" | (double)s | endl;
         struct S { int i, j; } 0 = { 0, 0 }, 1 = { 1, 1 };
 …
         } // for
         sout | "sum from" | low | "to" | High | "is"
                  | sum( size, (S *)a ) | "" | ", check" | (S)s | endl;
+                 | sum( size, (S *)a ) | ", check" | (S)s | endl;
 } // main

src/examples/vector_int.c

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // vector_int.c --
+// vector_int.c --
 //
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:38:05 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:27:12 2016
 // Update Count     : 3
 //
 …
 #define DEFAULT_CAPACITY 20
 vector_int vector_int_allocate() {
         return vector_int_allocate( DEFAULT_CAPACITY );
+void ?{}( vector_int * vec ) {
+        vec { DEFAULT_CAPACITY };
+}
+vector_int vector_int_allocate( int reserve ) {
+        vector_int new_vector;
+        new_vector.last = -1;
+        new_vector.capacity = reserve;
+        new_vector.data = malloc( sizeof( int ) * reserve );
+        return new_vector;
+void ?{}( vector_int * vec, int reserve ) {
+        vec->last = -1;
+        vec->capacity = reserve;
+        vec->data = malloc( sizeof( int ) * reserve );
+}
+void vector_int_deallocate( vector_int vec ) {
+        free( vec.data );
+void ?{}( vector_int * vec, vector_int other ) {
+        vec->last = other.last;
+        vec->capacity = other.capacity;
+        vec->data = malloc( sizeof( int ) * other.capacity );
+        for (int i = 0; i < vec->last; i++) {
+                vec->data[i] = other.data[i];
+        }
+}
+void ^?{}( vector_int * vec ) {
+        free( vec->data );
+}
 …
 // implement bounded_array
 lvalue int ?[?]( vector_int vec, int index ) {
         return vec.data[ index ];
+lvalue int ?[?]( vector_int * vec, int index ) {
+        return vec->data[ index ];
+}
 int last( vector_int vec ) {
         return vec.last;
+int last( vector_int * vec ) {
+        return vec->last;
+}

src/examples/vector_int.h

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // vector_int.h --
+// vector_int.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 27 18:39:05 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:26:59 2016
 // Update Count     : 2
 //
 …
 } vector_int;
+vector_int vector_int_allocate();                                               // allocate vector with default capacity
+vector_int vector_int_allocate( int reserve );                  // allocate vector with specified capacity
+void vector_int_deallocate( vector_int );                               // deallocate vector's storage
+void ?{}( vector_int * );                                                               // allocate vector with default capacity
+void ?{}( vector_int *, int reserve );          // allocate vector with specified capacity
+void ?{}( vector_int * vec, vector_int other ); // copy constructor
+void ^?{}( vector_int * );                                                              // deallocate vector's storage
 void reserve( vector_int *vec, int reserve );                   // reserve more capacity
 …
 // implement bounded_array
 lvalue int ?[?]( vector_int vec, int index );                   // access to arbitrary element (does not resize)
 int last( vector_int vec );                                                             // return last element
+lvalue int ?[?]( vector_int * vec, int index );                 // access to arbitrary element (does not resize)
+int last( vector_int * vec );                                                           // return last element
 #endif // VECTOR_INT_H

src/examples/vector_test.c

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // vector_test.c --
+// vector_test.c --
 //
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb 17 12:23:55 2016
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Apr 27 17:31:27 2016
 // Update Count     : 18
 //
 …
 int main( void ) {
         vector_int vec = vector_int_allocate();
+        vector_int vec;
         // read in numbers until EOF or error
 …
         sout | "Array elements:" | endl;
         write( begin( vec ), end( vec ), sout );
+        write( begin( &vec ), end( &vec ), sout );
         sout | endl;
         sout | "Array elements reversed:" | endl;
         write_reverse( begin( vec ), end( vec ), sout );
+        write_reverse( begin( &vec ), end( &vec ), sout );
         sout | endl;
+}

src/initialization.txt

-              rbb8ea30
+              rd668182
 sure that resolved initializers for all declarations are being
 generated.
+------
+More recent email: (I am quoted; Richard is the responder)
+> As far as I'm aware, the only way that I could currently get the correct
+> results from the unification engine is by feeding it an expression that
+> looks like "?=?( ((struct Y)x.y).a, 10 )", then picking out the pieces that
+> I need (namely the correct choice for a). Does this seem like a reasonable
+> approach to solve this problem?
+No, unfortunately. Initialization isn't being rewritten as assignment,
+so you shouldn't allow the particular selection of assignment
+operators that happen to be in scope (and which may include
+user-defined operators) to guide the type resolution.
+I don't think there is any way to rewrite an initializer as a single
+expression and have the resolver just do the right thing. I see the
+algorithm as:
+For each alternative interpretation of the designator:
+  Construct an expression that casts the initializer to the type of
+    the designator
+  Construct an AlternativeFinder and use it to find the lowest cost
+    interpretation of the expression
+  Add this interpretation to a list of possibilities
+Go through the list of possibilities and pick the lowest cost
+As with many things in the resolver, it's conceptually simple but the
+implementation may be a bit of a pain. It fits in with functions like
+findSingleExpression, findIntegralExpression in Resolver.cc, although
+it will be significantly more complicated than any of the existing
+ones.

src/libcfa/Makefile.am

-              rbb8ea30
+              rd668182
 ## file "LICENCE" distributed with Cforall.
 ##
 ## Makefile.am --
+## Makefile.am --
 ##
 ## Author           : Peter A. Buhr
 …
 CFLAGS = -g -Wall -Wno-unused-function -B${abs_top_srcdir}/src/driver -XCFA -t  # TEMPORARY: does not build with -O2
 CC = ${abs_top_srcdir}/src/driver/cfa
+CC = ${abs_top_srcdir}/src/driver/cfa
 # extension-less header files are overridden by default make rules => explicitly override rule
 …
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
+CLEANFILES = libcfa-prelude.c
 MAINTAINERCLEANFILES += ${includedir}/*

src/libcfa/Makefile.in

-              rbb8ea30
+              rd668182
 AWK = @AWK@
 BACKEND_CC = @BACKEND_CC@
 CC = ${abs_top_srcdir}/src/driver/cfa
+CC = ${abs_top_srcdir}/src/driver/cfa
 CCDEPMODE = @CCDEPMODE@
 CFA_BINDIR = @CFA_BINDIR@
 …
 cfaheaders = # limits
 include_HEADERS = ${cheaders:=.h} ${libs} ${cfaheaders}
+CLEANFILES = libcfa-prelude.c
 all: all-am
 …
 clean-generic:
+        -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
 distclean-generic:

src/libcfa/fstream

-              rbb8ea30
+              rd668182
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 19 20:44:10 2016
 // Update Count     : 84
+// Last Modified On : Thu Apr 28 08:08:04 2016
+// Update Count     : 88
 //
 …
 struct ofstream {
         void *file;
         int sepDefault;
         int sepOnOff;
+        _Bool sepDefault;
+        int sepOnOff;                                                                           // FIX ME: type should be _Bool
         char separator[separateSize];
 }; // ofstream

src/libcfa/fstream.c

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // fstream.c --
+// fstream.c --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr  6 17:55:27 2016
 // Update Count     : 176
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon May 02 15:14:52 2016
+// Update Count     : 187
 //
 …
         if ( fclose( (FILE *)(os->file) ) == EOF ) {
                 perror( IO_MSG "close output" );
         } // if
+        } // if
 } // close
 …
 int prtfmt( ofstream * os, const char fmt[], ... ) {
     va_list args;
     va_start( args, fmt );
     int len = vfprintf( (FILE *)(os->file), fmt, args );
 …
         } // if
     va_end( args );
+        sepReset( os );                                                                         // reset separator
         return len;
 } // prtfmt
 …
         if ( fclose( (FILE *)(is->file) ) == EOF ) {
                 perror( IO_MSG "close input" );
         } // if
+        } // if
 } // close
 …
         return is;
 } // read
 ifstream *ungetc( ifstream * is, char c ) {
         if ( fail( is ) ) {

src/libcfa/iostream.c

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // iostream.c --
+// iostream.c --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr  6 16:13:29 2016
 // Update Count     : 278
+// Last Modified By : Rob Schluntz
+// Last Modified On : Mon May 02 15:13:55 2016
+// Update Count     : 302
 //
 …
 ostype * ?|?( ostype *os, short int si ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%hd", si );
         return os;
 …
 ostype * ?|?( ostype *os, unsigned short int usi ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%hu", usi );
         return os;
 …
 ostype * ?|?( ostype *os, int i ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%d", i );
         return os;
 …
 ostype * ?|?( ostype *os, unsigned int ui ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%u", ui );
         return os;
 …
 ostype * ?|?( ostype *os, long int li ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%ld", li );
         return os;
 …
 ostype * ?|?( ostype *os, unsigned long int uli ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%lu", uli );
         return os;
 …
 ostype * ?|?( ostype *os, long long int lli ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%lld", lli );
         return os;
 …
 ostype * ?|?( ostype *os, unsigned long long int ulli ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%llu", ulli );
         return os;
 …
 ostype * ?|?( ostype *os, float f ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%g", f );
         return os;
 …
 ostype * ?|?( ostype *os, double d ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%.*lg", DBL_DIG, d );
         return os;
 …
 ostype * ?|?( ostype *os, long double ld ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%.*Lg", LDBL_DIG, ld );
         return os;
 …
                 // opening delimiters
                 ['('] : Open, ['['] : Open, ['{'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
+                ['$'] : Open, [(unsigned char)'£'] : Open, [(unsigned char)'¥'] : Open,
+                [(unsigned char)'¡'] : Open, [(unsigned char)'¿'] : Open, [(unsigned char)'«'] : Open,
                 // closing delimiters
                 [','] : Close, ['.'] : Close, [':'] : Close, [';'] : Close, ['!'] : Close, ['?'] : Close,
 …
                 // opening-closing delimiters
                 ['\''] : OpenClose, ['`'] : OpenClose, ['"'] : OpenClose,
                 ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
+                [' '] : OpenClose, ['\f'] : OpenClose, ['\n'] : OpenClose, ['\r'] : OpenClose, ['\t'] : OpenClose, ['\v'] : OpenClose, // isspace
         }; // mask
+        int len = strlen( cp );
+        // null string => no separator
+  if ( len == 0 ) { sepOff( os ); return os; }
+  if ( cp[0] == '\0' ) { sepOff( os ); return os; }             // null string => no separator
         // first character IS NOT spacing or closing punctuation => add left separator
         unsigned char ch = cp[0];                                                       // must make unsigned
 …
                 prtfmt( os, "%s", sepGet( os ) );
         } // if
+        // if string starts line, must reset to determine open state because separator is off
+        sepReset( os );                                                                         // reset separator
         // last character IS spacing or opening punctuation => turn off separator for next item
         unsigned int posn = len - 1;
+        unsigned int len = strlen( cp ), posn = len - 1;
         ch = cp[posn];                                                                          // must make unsigned
+        if ( mask[ ch ] == Open || mask[ ch ] == OpenClose ) {
+        if ( sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                sepOn( os );
+        } else {
                 sepOff( os );
-        } else {
-                sepOn( os );
         } // if
         return write( os, cp, len );
 …
 ostype * ?|?( ostype *os, const void *p ) {
         if ( sepPrt( os ) ) prtfmt( os, "%s", sepGet( os ) );
-        sepReset( os );
         prtfmt( os, "%p", p );
         return os;
 …
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype *os, ostype * (* manip)( ostype * ) ) {
         return manip( os );
 } // ?|?
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * endl( ostype * os ) {
         os | '\n';
 …
 } // endl
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * sepOn( ostype * os ) {
         sepOn( os );
 …
 } // sepOn
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * sepOff( ostype * os ) {
         sepOff( os );
 …
 } // sepOff
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * sepEnable( ostype * os ) {
         sepEnable( os );
 …
 } // sepEnable
 forall( dtype ostype | ostream( ostype ) )
+forall( dtype ostype | ostream( ostype ) )
 ostype * sepDisable( ostype * os ) {
         sepDisable( os );
 …
 } // ?|?
 _Istream_cstrUC cstr( char * s ) { _Istream_cstrUC s = { s }; return s; }
+_Istream_cstrUC cstr( char * str ) { _Istream_cstrUC s = { str }; return s; }
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, _Istream_cstrUC cstr ) {
 …
 } // cstr
 _Istream_cstrC cstr( char * s, int size ) { _Istream_cstrC s = { s, size }; return s; }
+_Istream_cstrC cstr( char * str, int size ) { _Istream_cstrC s = { str, size }; return s; }
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, _Istream_cstrC cstr ) {

src/libcfa/prelude.cf

-              rbb8ea30
+              rd668182
 # 2 "prelude.cf"  // needed for error messages from this file
 //                               -*- Mode: C -*-
 //
+//                               -*- Mode: C -*-
+//
 // Copyright (C) Glen Ditchfield 1994, 1999
 //
+//
 // prelude.cf -- Standard Cforall Preample for C99
 //
+//
 // Author           : Glen Ditchfield
 // Created On       : Sat Nov 29 07:23:41 2014
 …
 forall( ftype FT ) lvalue FT             *?( FT * );
 _Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
 signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );
 unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );
 signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );
 unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );
 signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );
 unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int );
+_Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
+signed int              +?( signed int ),               -?( signed int ),               ~?( signed int );
+unsigned int            +?( unsigned int ),             -?( unsigned int ),             ~?( unsigned int );
+signed long int         +?( signed long int ),          -?( signed long int ),          ~?( signed long int );
+unsigned long int       +?( unsigned long int ),        -?( unsigned long int ),        ~?( unsigned long int );
+signed long long int    +?( signed long long int ),     -?( signed long long int ),     ~?( signed long long int );
+unsigned long long int  +?( unsigned long long int ),   -?( unsigned long long int ),   ~?( unsigned long long int );
 float                   +?( float ),                    -?( float );
 double                  +?( double ),                   -?( double );
 …
                         ?+=?( long double _Complex *, long double _Complex ), ?+=?( volatile long double _Complex *, long double _Complex ),
                         ?-=?( long double _Complex *, long double _Complex ), ?-=?( volatile long double _Complex *, long double _Complex );
+// ------------------------------------------------------------
+//
+// Section ??? Constructors and Destructors
+//
+// ------------------------------------------------------------
+// default ctor
+void    ?{}( _Bool * ),                         ?{}( volatile _Bool * );
+void    ?{}( char * ),  ?{}( volatile char * );
+void    ?{}( unsigned char * ), ?{}( volatile unsigned char * );
+void    ?{}( char signed * ),                   ?{}( volatile char signed * );
+void    ?{}( int short * ),                             ?{}( volatile int short * );
+void    ?{}( int short unsigned * ),    ?{}( volatile int short unsigned * );
+void    ?{}( signed int * ),                    ?{}( volatile signed int * );
+void    ?{}( unsigned int * ),                  ?{}( volatile unsigned int * );
+void    ?{}( signed long int * ),               ?{}( volatile signed long int * );
+void    ?{}( unsigned long int * ),             ?{}( volatile unsigned long int * );
+void    ?{}( signed long long int * ),          ?{}( volatile signed long long int * );
+void    ?{}( unsigned long long int * ),        ?{}( volatile unsigned long long int * );
+void    ?{}( float * ),                         ?{}( volatile float * );
+void    ?{}( double * ),                        ?{}( volatile double * );
+void    ?{}( long double * ),                   ?{}( volatile long double * );
+void    ?{}( float _Complex * ),                ?{}( volatile float _Complex * );
+void    ?{}( double _Complex * ),               ?{}( volatile double _Complex * );
+void    ?{}( long double _Complex * ),          ?{}( volatile long double _Complex * );
+// copy ctor
+void    ?{}( _Bool *, _Bool ),                                  ?{}( volatile _Bool *, _Bool );
+void    ?{}( char *, char ),    ?{}( volatile char *, char );
+void    ?{}( unsigned char *, unsigned char ),                  ?{}( volatile unsigned char *, unsigned char );
+void    ?{}( char signed *, char signed ),                      ?{}( volatile char signed *, char signed );
+void    ?{}( int short *, int short ),                          ?{}( volatile int short *, int short );
+void    ?{}( int short unsigned *, int short unsigned ),        ?{}( volatile int short unsigned *, int short unsigned );
+void    ?{}( signed int *, signed int),                         ?{}( volatile signed int *, signed int );
+void    ?{}( unsigned int *, unsigned int),                     ?{}( volatile unsigned int *, unsigned int );
+void    ?{}( signed long int *, signed long int),               ?{}( volatile signed long int *, signed long int );
+void    ?{}( unsigned long int *, unsigned long int),           ?{}( volatile unsigned long int *, unsigned long int );
+void    ?{}( signed long long int *, signed long long int),     ?{}( volatile signed long long int *, signed long long int );
+void    ?{}( unsigned long long int *, unsigned long long int), ?{}( volatile unsigned long long int *, unsigned long long int );
+void    ?{}( float *, float),                                   ?{}( volatile float *, float );
+void    ?{}( double *, double),                                 ?{}( volatile double *, double );
+void    ?{}( long double *, long double),                       ?{}( volatile long double *, long double );
+void    ?{}( float _Complex *, float _Complex),                 ?{}( volatile float _Complex *, float _Complex );
+void    ?{}( double _Complex *, double _Complex),               ?{}( volatile double _Complex *, double _Complex );
+void    ?{}( long double _Complex *, long double _Complex),     ?{}( volatile long double _Complex *, long double _Complex );
+// dtor
+void    ^?{}( _Bool * ),                        ^?{}( volatile _Bool * );
+void    ^?{}( char * ), ^?{}( volatile char * );
+void    ^?{}( char unsigned * ),                        ^?{}( volatile char unsigned * );
+void    ^?{}( char signed * ),                  ^?{}( volatile char signed * );
+void    ^?{}( int short * ),                            ^?{}( volatile int short * );
+void    ^?{}( int short unsigned * ),   ^?{}( volatile int short unsigned * );
+void    ^?{}( signed int * ),                   ^?{}( volatile signed int * );
+void    ^?{}( unsigned int * ),                 ^?{}( volatile unsigned int * );
+void    ^?{}( signed long int * ),              ^?{}( volatile signed long int * );
+void    ^?{}( unsigned long int * ),            ^?{}( volatile unsigned long int * );
+void    ^?{}( signed long long int * ),         ^?{}( volatile signed long long int * );
+void    ^?{}( unsigned long long int * ),       ^?{}( volatile unsigned long long int * );
+void    ^?{}( float * ),                        ^?{}( volatile float * );
+void    ^?{}( double * ),                       ^?{}( volatile double * );
+void    ^?{}( long double * ),                  ^?{}( volatile long double * );
+void    ^?{}( float _Complex * ),               ^?{}( volatile float _Complex * );
+void    ^?{}( double _Complex * ),              ^?{}( volatile double _Complex * );
+void    ^?{}( long double _Complex * ),         ^?{}( volatile long double _Complex * );
+// // default ctor
+// forall( dtype DT ) void       ?{}(                DT ** );
+// forall( dtype DT ) void       ?{}( const          DT ** );
+// forall( dtype DT ) void       ?{}(       volatile DT ** );
+// forall( dtype DT ) void       ?{}( const volatile DT ** );
+// // copy ctor
+// forall( dtype DT ) void       ?{}(                DT **, DT* );
+// forall( dtype DT ) void       ?{}( const          DT **, DT* );
+// forall( dtype DT ) void       ?{}(       volatile DT **, DT* );
+// forall( dtype DT ) void       ?{}( const volatile DT **, DT* );
+// // dtor
+// forall( dtype DT ) void      ^?{}(                DT ** );
+// forall( dtype DT ) void      ^?{}( const          DT ** );
+// forall( dtype DT ) void      ^?{}(       volatile DT ** );
+// forall( dtype DT ) void      ^?{}( const volatile DT ** );
+// copied from assignment section
+// copy constructors
+forall( ftype FT ) void ?{}( FT **, FT * );
+forall( ftype FT ) void ?{}( FT * volatile *, FT * );
+forall( dtype DT ) void ?{}(                 DT *          *,                   DT * );
+forall( dtype DT ) void ?{}(                 DT * volatile *,                   DT * );
+forall( dtype DT ) void ?{}( const           DT *          *,                   DT * );
+forall( dtype DT ) void ?{}( const           DT * volatile *,                   DT * );
+forall( dtype DT ) void ?{}( const           DT *          *, const             DT * );
+forall( dtype DT ) void ?{}( const           DT * volatile *, const             DT * );
+forall( dtype DT ) void ?{}(       volatile  DT *          *,                   DT * );
+forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   DT * );
+forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    DT * );
+forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *,                   DT * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *, const             DT * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    DT * );
+forall( dtype DT ) void ?{}(                 DT *          *,                   void * );
+forall( dtype DT ) void ?{}(                 DT * volatile *,                   void * );
+forall( dtype DT ) void ?{}( const           DT *          *,                   void * );
+forall( dtype DT ) void ?{}( const           DT * volatile *,                   void * );
+forall( dtype DT ) void ?{}( const           DT *          *, const             void * );
+forall( dtype DT ) void ?{}( const           DT * volatile *, const             void * );
+forall( dtype DT ) void ?{}(       volatile  DT *          *,                   void * );
+forall( dtype DT ) void ?{}(       volatile  DT * volatile *,                   void * );
+forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    void * );
+forall( dtype DT ) void ?{}(       volatile  DT * volatile *,       volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *,                   void * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *,                   void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *, const             void * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const             void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *,       volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *, const volatile    void * );
+forall( dtype DT ) void ?{}(                 void *          *,                 DT * );
+forall( dtype DT ) void ?{}(                 void * volatile *,                 DT * );
+forall( dtype DT ) void ?{}( const           void *          *,                 DT * );
+forall( dtype DT ) void ?{}( const           void * volatile *,                 DT * );
+forall( dtype DT ) void ?{}( const           void *          *, const           DT * );
+forall( dtype DT ) void ?{}( const           void * volatile *, const           DT * );
+forall( dtype DT ) void ?{}(        volatile void *          *,                 DT * );
+forall( dtype DT ) void ?{}(        volatile void * volatile *,                 DT * );
+forall( dtype DT ) void ?{}(        volatile void *          *,       volatile  DT * );
+forall( dtype DT ) void ?{}(        volatile void * volatile *,       volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void *           *,                 DT * );
+forall( dtype DT ) void ?{}( const volatile void * volatile *,                  DT * );
+forall( dtype DT ) void ?{}( const volatile void *           *, const           DT * );
+forall( dtype DT ) void ?{}( const volatile void * volatile *, const            DT * );
+forall( dtype DT ) void ?{}( const volatile void *           *,       volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void * volatile *,        volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void *           *, const volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void * volatile *, const volatile   DT * );
+void    ?{}(                void *          *,                void * );
+void    ?{}(                void * volatile *,                void * );
+void    ?{}( const          void *          *,                void * );
+void    ?{}( const          void * volatile *,                void * );
+void    ?{}( const          void *          *, const          void * );
+void    ?{}( const          void * volatile *, const          void * );
+void    ?{}(       volatile void *          *,                void * );
+void    ?{}(       volatile void * volatile *,                void * );
+void    ?{}(       volatile void *          *,       volatile void * );
+void    ?{}(       volatile void * volatile *,       volatile void * );
+void    ?{}( const volatile void *          *,                void * );
+void    ?{}( const volatile void * volatile *,                void * );
+void    ?{}( const volatile void *          *, const          void * );
+void    ?{}( const volatile void * volatile *, const          void * );
+void    ?{}( const volatile void *          *,       volatile void * );
+void    ?{}( const volatile void * volatile *,       volatile void * );
+void    ?{}( const volatile void *          *, const volatile void * );
+void    ?{}( const volatile void * volatile *, const volatile void * );
+//forall( dtype DT ) void ?{}(              DT *          *, forall( dtype DT2 ) const DT2 * );
+//forall( dtype DT ) void ?{}(              DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) void ?{}( const          DT *          *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) void ?{}( const          DT * volatile *, forall( dtype DT2 ) const DT2 * );
+//forall( dtype DT ) void ?{}( volatile     DT *          *, forall( dtype DT2 ) const DT2 * );
+//forall( dtype DT ) void ?{}( volatile     DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) void ?{}( const volatile DT *          *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) void ?{}( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( ftype FT ) void ?{}( FT *          *, forall( ftype FT2 ) FT2 * );
+forall( ftype FT ) void ?{}( FT * volatile *, forall( ftype FT2 ) FT2 * );
+// default ctors
+forall( ftype FT ) void ?{}( FT *          * );
+forall( ftype FT ) void ?{}( FT * volatile * );
+forall( dtype DT ) void ?{}(                 DT *          *);
+forall( dtype DT ) void ?{}(                 DT * volatile *);
+forall( dtype DT ) void ?{}( const           DT *          *);
+forall( dtype DT ) void ?{}( const           DT * volatile *);
+forall( dtype DT ) void ?{}(       volatile  DT *          *);
+forall( dtype DT ) void ?{}(       volatile  DT * volatile *);
+forall( dtype DT ) void ?{}( const volatile  DT *          *);
+forall( dtype DT ) void ?{}( const volatile  DT * volatile *);
+void    ?{}(                void *          *);
+void    ?{}(                void * volatile *);
+void    ?{}( const          void *          *);
+void    ?{}( const          void * volatile *);
+void    ?{}(       volatile void *          *);
+void    ?{}(       volatile void * volatile *);
+void    ?{}( const volatile void *          *);
+void    ?{}( const volatile void * volatile *);
+// dtors
+forall( ftype FT ) void ^?{}( FT *         * );
+forall( ftype FT ) void ^?{}( FT * volatile * );
+forall( dtype DT ) void ^?{}(                DT *          *);
+forall( dtype DT ) void ^?{}(                DT * volatile *);
+forall( dtype DT ) void ^?{}( const          DT *          *);
+forall( dtype DT ) void ^?{}( const          DT * volatile *);
+forall( dtype DT ) void ^?{}(      volatile  DT *          *);
+forall( dtype DT ) void ^?{}(      volatile  DT * volatile *);
+forall( dtype DT ) void ^?{}( const volatile  DT *         *);
+forall( dtype DT ) void ^?{}( const volatile  DT * volatile *);
+void    ^?{}(               void *          *);
+void    ^?{}(               void * volatile *);
+void    ^?{}( const         void *          *);
+void    ^?{}( const         void * volatile *);
+void    ^?{}(      volatile void *          *);
+void    ^?{}(      volatile void * volatile *);
+void    ^?{}( const volatile void *         *);
+void    ^?{}( const volatile void * volatile *);

src/libcfa/rational

-              rbb8ea30
+              rd668182
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Apr  8 11:38:27 2016
 // Update Count     : 15
+// Last Modified On : Wed May  4 14:11:45 2016
+// Update Count     : 16
 //
 …
 // constructors
 Rational rational();
 Rational rational( long int n );
 Rational rational( long int n, long int d );
+void ?{}( Rational * r );
+void ?{}( Rational * r, long int n );
+void ?{}( Rational * r, long int n, long int d );
 // getter/setter for numerator/denominator

src/libcfa/rational.c

-              rbb8ea30
+              rd668182
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 21 07:33:03 2016
 // Update Count     : 22
+// Last Modified On : Wed May  4 14:16:14 2016
+// Update Count     : 25
 //
 …
 // constructors
 Rational rational() {
     return (Rational){ 0, 1 };
+void ?{}( Rational * r ) {
+    r{ 0, 1 };
 } // rational
 Rational rational( long int n ) {
     return (Rational){ n, 1 };
+void ?{}( Rational * r, long int n ) {
+    r{ n, 1 };
 } // rational
 Rational rational( long int n, long int d ) {
+void ?{}( Rational * r, long int n, long int d ) {
     long int t = simplify( &n, &d );                                    // simplify
+    return (Rational){ n / t, d / t };
+    r->numerator = n / t;
+        r->denominator = d / t;
 } // rational
 …
 Rational narrow( double f, long int md ) {
         if ( md <= 1 ) {                                                                        // maximum fractional digits too small?
+                Rational t = rational( f, 1 );                                  // truncate fraction
+                return t;
+                return (Rational){ f, 1};                                               // truncate fraction
         } // if
 …
                 k[2] = x * k[1] + k[0]; k[0] = k[1]; k[1] = k[2];
         } // for
+        Rational t = rational( neg ? -h[1] : h[1], k[1] );
+        return t;
+        return (Rational){ neg ? -h[1] : h[1], k[1] };
 } // narrow

src/libcfa/stdlib

-              rbb8ea30
+              rd668182
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 21 07:55:21 2016
 // Update Count     : 95
+// Last Modified On : Wed Apr 27 22:03:29 2016
+// Update Count     : 96
 //
 …
 forall( otype T ) T * aligned_alloc( size_t alignment );
 forall( otype T ) T * memalign( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );             // deprecated
 forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );

src/libcfa/stdlib.c

-              rbb8ea30
+              rd668182
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 21 07:58:29 2016
 // Update Count     : 165
+// Last Modified On : Thu Apr 28 07:54:21 2016
+// Update Count     : 166
 //
 …
 //---------------------------------------
 forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
+// forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
+// [ T, T ] div( T t1, T t2 ) { return [ t1 / t2, t1 % t2 ]; }
 //---------------------------------------

src/main.cc

-              rbb8ea30
+              rd668182
 // file "LICENCE" distributed with Cforall.
 //
 // main.cc --
+// main.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jan 27 22:20:20 2016
 // Update Count     : 199
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 06 15:59:09 2016
+// Update Count     : 203
 //
 …
 #include "MakeLibCfa.h"
 #include "InitTweak/Mutate.h"
+#include "InitTweak/RemoveInit.h"
+#include "InitTweak/GenInit.h"
+#include "InitTweak/FixInit.h"
+#include "InitTweak/FixGlobalInit.h"
 //#include "Explain/GenProlog.h"
 //#include "Try/Visit.h"
 …
 static void parse( FILE * input, LinkageSpec::Type t, bool shouldExit = false );
 static void dump( std::list< Declaration * > & translationUnit );
+static void dump( std::list< Declaration * > & translationUnit, std::ostream & out = std::cout );
 bool
         astp = false,
         bresolvep = false,
+        bboxp = false,
+        ctorinitp = false,
         exprp = false,
         expraltp = false,
 …
         codegenp = false;
 enum { Ast, Bresolver, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, Validate, };
+enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, Validate, };
 static struct option long_opts[] = {
         { "ast", no_argument, 0, Ast },
+        { "before-box", no_argument, 0, Bbox },
         { "before-resolver", no_argument, 0, Bresolver },
+        { "ctorinitfix", no_argument, 0, CtorInitFix },
         { "expr", no_argument, 0, Expr },
         { "expralt", no_argument, 0, ExprAlt },
 …
         std::ostream *output = &std::cout;
         int long_index;
+        std::list< Declaration* > translationUnit;
+        std::list< Declaration * > translationUnit;
+        const char *filename = NULL;
         opterr = 0;                                                                                     // prevent getopt from printing error messages
         int c;
         while ( (c = getopt_long( argc, argv, "abefglnpqrstvyzD:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcefglnpqrstvyzD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
 …
                         bresolvep = true;
                         break;
+                  case 'B':                                                                             // print before resolver steps
+                        bboxp = true;
+                        break;
+                  case CtorInitFix:
+                  case 'c':
+                        ctorinitp = true;
+                        break;
                   case Expr:
                   case 'e':                                                                             // dump AST after expression analysis
 …
                         break;
                   case 'D':                                                                             // ignore -Dxxx
+                        break;
+                  case 'F':                                                                             // source file-name without suffix
+                        filename = optarg;
                         break;
                   case '?':
 …
                         input = fopen( argv[ optind ], "r" );
                         if ( ! input ) {
                                 std::cout << "Error: can't open " << argv[optind] << std::endl;
+                                std::cout << "Error: can't open " << argv[ optind ] << std::endl;
                                 exit( 1 );
                         } // if
+                        // if running cfa-cpp directly, might forget to pass -F option (and really shouldn't have to)
+                        if ( filename == NULL ) filename = argv[ optind ];
+                        // prelude filename comes in differently
+                        if ( libcfap ) filename = "prelude.cf";
                         optind += 1;
                 } else {
 …
                         output = new ofstream( argv[ optind ] );
                 } // if
                 Parser::get_parser().set_debug( grammarp );
 …
                                         exit( 1 );
                                 } // if
                                 parse( prelude, LinkageSpec::Intrinsic );
                         } // if
                 } // if
                 parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, grammarp );
+                parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, grammarp );
                 if ( parsep ) {
                         Parser::get_parser().get_parseTree()->printList( std::cout );
 …
                 OPTPRINT( "mutate" )
                 ControlStruct::mutate( translationUnit );
                 OPTPRINT( "fixNames" )
+                OPTPRINT( "fixNames" )
                 CodeGen::fixNames( translationUnit );
+                OPTPRINT( "tweak" )
+                InitTweak::tweak( translationUnit );
+                OPTPRINT( "fixGlobalInit" );
+                InitTweak::fixGlobalInit( translationUnit, filename, libcfap || treep );
+                OPTPRINT( "tweakInit" )
+                InitTweak::genInit( translationUnit );
                 if ( libcfap ) {
 …
                 if ( exprp ) {
                         dump( translationUnit );
+                        return 0;
+                }
+                OPTPRINT( "fixInit" )
+                // fix ObjectDecl - replaces ConstructorInit nodes
+                InitTweak::fix( translationUnit );
+                if ( ctorinitp ) {
+                        dump ( translationUnit );
+                        return 0;
+                }
 …
                 OPTPRINT( "convertLvalue" )
                 GenPoly::convertLvalue( translationUnit );
+                if ( bboxp ) {
+                        dump( translationUnit );
+                        return 0;
+                }
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
                 // print tree right before code generation
                 if ( codegenp ) {
 …
         } catch ( SemanticError &e ) {
                 if ( errorp ) {
+                        dump( translationUnit );
+                        std::cerr << "---AST at error:---" << std::endl;
+                        dump( translationUnit, std::cerr );
+                        std::cerr << std::endl << "---End of AST, begin error message:---\n" << std::endl;
+                }
                 e.print( std::cerr );
 …
         } // try
+        deleteAll( translationUnit );
         return 0;
 } // main
 …
+}
 static void dump( std::list< Declaration * > & translationUnit ) {
+static void dump( std::list< Declaration * > & translationUnit, std::ostream & out ) {
         std::list< Declaration * > decls;
         if ( noprotop ) {
                 filter( translationUnit.begin(), translationUnit.end(),
+                filter( translationUnit.begin(), translationUnit.end(),
                                 std::back_inserter( decls ), notPrelude );
         } else {
 …
+        }
         printAll( decls, std::cout );
+        printAll( decls, out );
         deleteAll( translationUnit );
+}

Context Navigation

Changes in / [bb8ea30:d668182]

Legend:

Download in other formats: